chore(system): add utility Pair class

Adds the Pair class to standardize the code
and avoid any unnecessary dependencies on third-party libraries
for this type of utility.

.devcontainer/README.md

@@ -23,19 +23,9 @@ In the meantime, you can move onto the next step...
 
 ---
 
-### Requirements
-
-- Java 21 (LTS versions).
-  > ⚠️ Java 24 and above are not supported yet and will fail with `invalid source release: 21`.
-- Gradle (comes with wrapper `./gradlew`)
-- Docker (optional, for running Kestra in containers)
-
 ### Development:
 
-- (Optional) By default, your dev server will target `localhost:8080`. If your backend is running elsewhere, you can create `.env.development.local` under `ui` folder with this content:
-```
-VITE_APP_API_URL={myApiUrl}
-```
+- Create a `.env.development.local` file in the `ui` folder and paste the following:
 
 - Navigate into the `ui` folder and run `npm install` to install the dependencies for the frontend project.
 

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

@@ -2,7 +2,7 @@ name: Auto-Translate UI keys and create PR
 
 on:
   schedule:
-    - cron: "0 9-21/3 * * *"  # Every 3 hours from 9 AM to 9 PM
+    - cron: "0 9-21 * * *"  # Every hour from 9 AM to 9 PM
   workflow_dispatch:
     inputs:
       retranslate_modified_keys:
@@ -20,13 +20,13 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-        - uses: actions/checkout@v5
+        - uses: actions/checkout@v4
           name: Checkout
           with:
             fetch-depth: 0
 
         - name: Set up Python
-          uses: actions/setup-python@v6
+          uses: actions/setup-python@v5
           with:
             python-version: "3.x"
 
@@ -39,7 +39,7 @@ jobs:
             OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
 
         - name: Set up Node
-          uses: actions/setup-node@v5
+          uses: actions/setup-node@v4
           with:
             node-version: "20.x"
 

.github/workflows/codeql-analysis.yml

@@ -27,7 +27,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v5
+      uses: actions/checkout@v4
       with:
         # We must fetch at least the immediate parents so that if this is
         # a pull request then we can checkout the head.
@@ -50,7 +50,7 @@ jobs:
 
     # Set up JDK
     - name: Set up JDK
-      uses: actions/setup-java@v5
+      uses: actions/setup-java@v4
       if: ${{ matrix.language == 'java' }}
       with:
         distribution: 'temurin'

.github/workflows/docker.yml

@@ -0,0 +1,178 @@
+name: Create Docker images on Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      retag-latest:
+        description: 'Retag latest Docker images'
+        required: true
+        type: string
+        default: "false"
+        options:
+          - "true"
+          - "false"
+      release-tag:
+        description: 'Kestra Release Tag'
+        required: false
+        type: string
+      plugin-version:
+        description: 'Plugin version'
+        required: false
+        type: string
+        default: "LATEST"
+      force-download-artifact:
+        description: 'Force download artifact'
+        required: false
+        type: string
+        default: "true"
+        options:
+          - "true"
+          - "false"
+
+env:
+  PLUGIN_VERSION: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
+jobs:
+  plugins:
+    name: List Plugins
+    runs-on: ubuntu-latest
+    outputs:
+      plugins: ${{ steps.plugins.outputs.plugins }}
+    steps:
+      # Checkout
+      - uses: actions/checkout@v4
+
+      # Get Plugins List
+      - name: Get Plugins List
+        uses: ./.github/actions/plugins-list
+        id: plugins
+        with:
+          plugin-version: ${{ env.PLUGIN_VERSION }}
+
+  # ********************************************************************************************************************
+  # Build
+  # ********************************************************************************************************************
+  build-artifacts:
+    name: Build Artifacts
+    if: ${{ github.event.inputs.force-download-artifact == 'true' }}
+    uses: ./.github/workflows/workflow-build-artifacts.yml
+
+  docker:
+    name: Publish Docker
+    needs: [ plugins, build-artifacts ]
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        image:
+          - name: "-no-plugins"
+            plugins: ""
+            packages: jattach
+            python-libs: ""
+          - name: ""
+            plugins: ${{needs.plugins.outputs.plugins}}
+            packages: python3 python-is-python3 python3-pip curl jattach
+            python-libs: kestra
+    steps:
+      - uses: actions/checkout@v4
+
+      # Vars
+      - name: Set image name
+        id: vars
+        run: |
+          if [[ "${{ inputs.release-tag }}" == "" ]]; then
+            TAG=${GITHUB_REF#refs/*/}
+            echo "tag=${TAG}" >> $GITHUB_OUTPUT
+          else
+            TAG="${{ inputs.release-tag }}"
+            echo "tag=${TAG}" >> $GITHUB_OUTPUT
+          fi
+
+          if [[ "${{ env.PLUGIN_VERSION }}" == *"-SNAPSHOT" ]]; then
+            echo "plugins=--repositories=https://central.sonatype.com/repository/maven-snapshots/ ${{ matrix.image.plugins }}" >> $GITHUB_OUTPUT;
+          else
+            echo "plugins=${{ matrix.image.plugins }}" >> $GITHUB_OUTPUT
+          fi
+
+      # [workflow_dispatch]
+      # Download executable from GitHub Release
+      - name: Artifacts - Download release (workflow_dispatch)
+        id: download-github-release
+        if: github.event_name == 'workflow_dispatch' && github.event.inputs.force-download-artifact == 'false'
+        uses: robinraju/release-downloader@v1.12
+        with:
+          tag: ${{steps.vars.outputs.tag}}
+          fileName: 'kestra-*'
+          out-file-path: build/executable
+
+      # [workflow_call]
+      # Download executable from artifact
+      - name: Artifacts - Download executable
+        if: github.event_name != 'workflow_dispatch' || steps.download-github-release.outcome == 'skipped'
+        uses: actions/download-artifact@v5
+        with:
+          name: exe
+          path: build/executable
+
+      - name: Copy exe to image
+        run: |
+          cp build/executable/* docker/app/kestra && chmod +x docker/app/kestra
+
+      # Docker setup
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Docker - Fix Qemu
+        shell: bash
+        run: |
+          docker run --rm --privileged multiarch/qemu-user-static --reset -p yes -c yes
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      # Docker Login
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_PASSWORD }}
+
+      # Docker Build and push
+      - name: Push to Docker Hub
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          tags: ${{ format('kestra/kestra:{0}{1}', steps.vars.outputs.tag, matrix.image.name) }}
+          platforms: linux/amd64,linux/arm64
+          build-args: |
+            KESTRA_PLUGINS=${{ steps.vars.outputs.plugins }}
+            APT_PACKAGES=${{ matrix.image.packages }}
+            PYTHON_LIBRARIES=${{ matrix.image.python-libs }}
+
+      - name: Install regctl
+        if: github.event.inputs.retag-latest == 'true'
+        uses: regclient/actions/regctl-installer@main
+
+      - name: Retag to latest
+        if: github.event.inputs.retag-latest == 'true'
+        run: |
+          regctl image copy ${{ format('kestra/kestra:{0}{1}', steps.vars.outputs.tag, matrix.image.name) }} ${{ format('kestra/kestra:latest{0}', matrix.image.name) }}
+
+  end:
+    runs-on: ubuntu-latest
+    needs:
+      - docker
+    if: always()
+    env:
+      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+    steps:
+
+      # Slack
+      - name: Slack notification
+        uses: Gamesight/slack-workflow-status@master
+        if: ${{ always() && env.SLACK_WEBHOOK_URL != 0 }}
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          slack_webhook_url: ${{ secrets.SLACK_WEBHOOK_URL }}
+          name: GitHub Actions
+          icon_emoji: ':github-actions:'
+          channel: 'C02DQ1A7JLR' # _int_git channel

.github/workflows/e2e.yml

@@ -19,7 +19,7 @@ on:
         default: "no input"
 jobs:
   check:
-    timeout-minutes: 15
+    timeout-minutes: 10
     runs-on: ubuntu-latest
     env:
       GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
@@ -32,12 +32,12 @@ jobs:
           password: ${{ github.token }}
 
       - name: Checkout kestra
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
         with:
           path: kestra
 
       # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
+      - uses: kestra-io/actions/.github/actions/setup-build@main
         name: Setup - Build
         id: build
         with:

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

@@ -4,7 +4,7 @@ on:
   workflow_dispatch:
     inputs:
       releaseVersion:
-        description: 'The release version (e.g., 0.21.0)'
+        description: 'The release version (e.g., 0.21.0-rc1)'
         required: true
         type: string
       nextVersion:
@@ -21,17 +21,25 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       # Checkout
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
+      # Checkout GitHub Actions
+      - uses: actions/checkout@v4
+        with:
+          repository: kestra-io/actions
+          path: actions
+          ref: main
+
       # 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
           python-enabled: true
+          caches-enabled: true
 
       # Get Plugins List
       - name: Get Plugins List
@@ -52,7 +60,7 @@ jobs:
           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}} \
@@ -65,10 +73,10 @@ jobs:
           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 }}
+          ${{ steps.plugins-list.outputs.repositories }}

.github/workflows/gradle-release.yml

@@ -4,7 +4,7 @@ on:
   workflow_dispatch:
     inputs:
       releaseVersion:
-        description: 'The release version (e.g., 0.21.0)'
+        description: 'The release version (e.g., 0.21.0-rc1)'
         required: true
         type: string
       nextVersion:
@@ -23,8 +23,8 @@ jobs:
       # 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$"
+          if ! [[ "$RELEASE_VERSION" =~ ^[0-9]+(\.[0-9]+)\.0-rc[01](-SNAPSHOT)?$ ]]; then
+            echo "Invalid release version. Must match regex: ^[0-9]+(\.[0-9]+)\.0-rc[01](-SNAPSHOT)?$"
             exit 1
           fi
 
@@ -33,13 +33,20 @@ jobs:
             exit 1;
           fi
       # Checkout
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
           path: kestra
 
+      # Checkout GitHub Actions
+      - uses: actions/checkout@v4
+        with:
+          repository: kestra-io/actions
+          path: actions
+          ref: main
+
       # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
+      - uses: ./actions/.github/actions/setup-build
         id: build
         with:
           java-enabled: true
@@ -71,6 +78,7 @@ jobs:
           git checkout develop;
 
           if [[ "$RELEASE_VERSION" == *"-SNAPSHOT" ]]; then
+            # -SNAPSHOT qualifier maybe used to test release-candidates
             ./gradlew release -Prelease.useAutomaticVersion=true \
             -Prelease.releaseVersion="${RELEASE_VERSION}" \
             -Prelease.newVersion="${NEXT_VERSION}" \
@@ -81,4 +89,4 @@ jobs:
             -Prelease.releaseVersion="${RELEASE_VERSION}" \
             -Prelease.newVersion="${NEXT_VERSION}" \
             -Prelease.pushReleaseVersionBranch="${PUSH_RELEASE_BRANCH}"
-          fi
+          fi

.github/workflows/main.yml

@@ -3,17 +3,10 @@ name: Main Workflow
 on:
   workflow_dispatch:
     inputs:
-      skip-test:
-        description: 'Skip test'
-        type: choice
-        required: true
-        default: 'false'
-        options:
-          - "true"
-          - "false"
       plugin-version:
-          description: "plugins version"
-          required: false
+          description: "Kestra version"
+          default: 'LATEST'
+          required: true
           type: string
   push:
     branches:
@@ -32,17 +25,16 @@ jobs:
   tests:
     name: Execute tests
     uses: ./.github/workflows/workflow-test.yml
-    if: ${{ github.event.inputs.skip-test == 'false' || github.event.inputs.skip-test == '' }}
     with:
       report-status: false
 
   release:
     name: Release
     needs: [tests]
-    if: "!failure() && !cancelled() && !startsWith(github.ref, 'refs/heads/releases')"
+    if: "!startsWith(github.ref, 'refs/heads/releases')"
     uses: ./.github/workflows/workflow-release.yml
     with:
-        plugin-version: ${{ inputs.plugin-version != '' && inputs.plugin-version || (github.ref == 'refs/heads/develop' && 'LATEST-SNAPSHOT' || 'LATEST') }}
+        plugin-version: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
     secrets:
       DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
       DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
@@ -53,12 +45,13 @@ jobs:
       SONATYPE_GPG_FILE: ${{ secrets.SONATYPE_GPG_FILE }}
       GH_PERSONAL_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}
       SLACK_RELEASES_WEBHOOK_URL: ${{ secrets.SLACK_RELEASES_WEBHOOK_URL }}
-
   end:
     runs-on: ubuntu-latest
     needs:
       - release
     if: always()
+    env:
+      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
     steps:
       - name: Trigger EE Workflow
         uses: peter-evans/repository-dispatch@v3
@@ -68,9 +61,14 @@ jobs:
           repository: kestra-io/kestra-ee
           event-type: "oss-updated"
 
+
       # Slack
       - name: Slack - Notification
-        if: ${{ failure() && env.SLACK_WEBHOOK_URL != 0 && (github.ref == 'refs/heads/master' || github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop') }}
-        uses: kestra-io/actions/composite/slack-status@main
+        uses: Gamesight/slack-workflow-status@master
+        if: ${{ always() && env.SLACK_WEBHOOK_URL != 0 }}
         with:
-          webhook-url: ${{ secrets.SLACK_WEBHOOK_URL }}
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          slack_webhook_url: ${{ secrets.SLACK_WEBHOOK_URL }}
+          name: GitHub Actions
+          icon_emoji: ":github-actions:"
+          channel: "C02DQ1A7JLR" # _int_git channel

.github/workflows/pull-request.yml

@@ -4,7 +4,6 @@ on:
   pull_request:
     branches:
       - develop
-      - releases/*
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref_name }}-pr
@@ -61,3 +60,19 @@ jobs:
     name: E2E - Tests
     uses: ./.github/workflows/e2e.yml
 
+  end:
+    name: End
+    runs-on: ubuntu-latest
+    if: always()
+    needs: [frontend, backend]
+    steps:
+      # Slack
+      - name: Slack notification
+        uses: Gamesight/slack-workflow-status@master
+        if: ${{ always() && env.SLACK_WEBHOOK_URL != 0 }}
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          slack_webhook_url: ${{ secrets.SLACK_WEBHOOK_URL }}
+          name: GitHub Actions
+          icon_emoji: ":github-actions:"
+          channel: "C02DQ1A7JLR"

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

@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       # Checkout
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
 

.github/workflows/setversion-tag.yml

@@ -34,14 +34,11 @@ jobs:
           fi
 
       # Checkout
-      - name: Checkout
-        uses: actions/checkout@v5
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-          token: ${{ secrets.GH_PERSONAL_TOKEN }}
 
-      # Configure
-      - name: Git - Configure
+      - 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]"
@@ -57,4 +54,4 @@ jobs:
           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
+          git push --tags

.github/workflows/vulnerabilities-check.yml

@@ -17,10 +17,17 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       # Checkout
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
+      # Checkout GitHub Actions
+      - uses: actions/checkout@v4
+        with:
+          repository: kestra-io/actions
+          path: actions
+          ref: main
+
       # Setup build
       - uses: ./actions/.github/actions/setup-build
         id: build
@@ -59,12 +66,19 @@ jobs:
       actions: read
     steps:
       # Checkout
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
+      # Checkout GitHub Actions
+      - uses: actions/checkout@v4
+        with:
+          repository: kestra-io/actions
+          path: actions
+          ref: main
+
       # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
+      - uses: ./actions/.github/actions/setup-build
         id: build
         with:
           java-enabled: false
@@ -73,7 +87,7 @@ jobs:
 
       # 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
+        uses: aquasecurity/trivy-action@0.32.0
         with:
           image-ref: kestra/kestra:develop
           format: 'template'
@@ -97,20 +111,28 @@ jobs:
       actions: read
     steps:
       # Checkout
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
+      # Checkout GitHub Actions
+      - uses: actions/checkout@v4
+        with:
+          repository: kestra-io/actions
+          path: actions
+          ref: main
+
       # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
+      - uses: ./actions/.github/actions/setup-build
         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
+        uses: aquasecurity/trivy-action@0.32.0
         with:
           image-ref: kestra/kestra:latest
           format: table

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

@@ -20,7 +20,6 @@ permissions:
   contents: write
   checks: write
   actions: read
-  pull-requests: write
 
 jobs:
   test:
@@ -30,13 +29,13 @@ jobs:
       GOOGLE_SERVICE_ACCOUNT: ${{ secrets.GOOGLE_SERVICE_ACCOUNT }}
       SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
         name: Checkout - Current ref
         with:
           fetch-depth: 0
 
       # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
+      - uses: kestra-io/actions/.github/actions/setup-build@main
         name: Setup - Build
         id: build
         with:
@@ -60,15 +59,84 @@ jobs:
           export GOOGLE_APPLICATION_CREDENTIALS=$HOME/.gcp-service-account.json
           ./gradlew check javadoc --parallel
 
-      - name: comment PR with test report
-        if: ${{ !cancelled() && github.event_name == 'pull_request' }}
+      # report test
+      - name: Test - Publish Test Results
+        uses: dorny/test-reporter@v2
+        if: always()
+        with:
+          name: Java Tests Report
+          reporter: java-junit
+          path: '**/build/test-results/test/TEST-*.xml'
+          list-suites: 'failed'
+          list-tests: 'failed'
+          fail-on-error: 'false'
+          token: ${{ secrets.GITHUB_AUTH_TOKEN }}
+
+      # Sonar
+      - name: Test - Analyze with Sonar
+        if: env.SONAR_TOKEN != ''
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_AUTH_TOKEN }}
-        run: npx --yes @kestra-io/kestra-devtools generateTestReportSummary --only-errors --ci $(pwd)
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+        shell: bash
+        run: ./gradlew sonar --info
 
-      # Report Java
-      - name: Report - Java
-        uses: kestra-io/actions/composite/report-java@main
-        if: ${{ !cancelled() }}
+      # GCP
+      - name: GCP - Auth with unit test account
+        id: auth
+        if: always() && env.GOOGLE_SERVICE_ACCOUNT != ''
+        continue-on-error: true
+        uses: "google-github-actions/auth@v2"
         with:
-          secrets: ${{ toJSON(secrets) }}
+          credentials_json: "${{ secrets.GOOGLE_SERVICE_ACCOUNT }}"
+
+      - name: GCP - Setup Cloud SDK
+        if: env.GOOGLE_SERVICE_ACCOUNT != ''
+        uses: "google-github-actions/setup-gcloud@v2"
+
+        # Allure check
+      - uses: rlespinasse/github-slug-action@v5
+        name: Allure - Generate slug variables
+
+      - name: Allure - Publish report
+        uses: andrcuns/allure-publish-action@v2.9.0
+        if: always() && env.GOOGLE_SERVICE_ACCOUNT != ''
+        continue-on-error: true
+        env:
+          GITHUB_AUTH_TOKEN: ${{ secrets.GITHUB_AUTH_TOKEN }}
+          JAVA_HOME: /usr/lib/jvm/default-jvm/
+        with:
+          storageType: gcs
+          resultsGlob: "**/build/allure-results"
+          bucket: internal-kestra-host
+          baseUrl: "https://internal.dev.kestra.io"
+          prefix: ${{ format('{0}/{1}', github.repository, 'allure/java') }}
+          copyLatest: true
+          ignoreMissingResults: true
+
+      # Jacoco
+      - name: Jacoco - Copy reports
+        if: env.GOOGLE_SERVICE_ACCOUNT != ''
+        continue-on-error: true
+        shell: bash
+        run: |
+          mv build/reports/jacoco/testCodeCoverageReport build/reports/jacoco/test/
+          mv build/reports/jacoco/test/testCodeCoverageReport.xml build/reports/jacoco/test/jacocoTestReport.xml
+          gsutil -m rsync -d -r  build/reports/jacoco/test/ gs://internal-kestra-host/${{ format('{0}/{1}', github.repository, 'jacoco') }}
+
+      # Codecov
+      - name: Codecov - Upload coverage reports
+        uses: codecov/codecov-action@v5
+        if: ${{ !cancelled() }}
+        continue-on-error: true
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          flags: backend
+
+      - name: Codecov - Upload test results
+        uses: codecov/test-results-action@v1
+        if: ${{ !cancelled() }}
+        continue-on-error: true
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          flags: backend

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

@@ -15,7 +15,7 @@ jobs:
       PLUGIN_VERSION: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
     steps:
       - name: Checkout - Current ref
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
@@ -26,7 +26,7 @@ jobs:
         run: npm ci
 
       # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
+      - uses: kestra-io/actions/.github/actions/setup-build@main
         name: Setup - Build
         id: build
         with:

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

@@ -20,7 +20,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
 
       - name: Cache Node Modules
         id: cache-node-modules

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

@@ -20,11 +20,20 @@ jobs:
     steps:
       # Check out
       - name: Checkout - Repository
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: true
 
+      # Checkout GitHub Actions
+      - name: Checkout - Actions
+        uses: actions/checkout@v4
+        with:
+          repository: kestra-io/actions
+          sparse-checkout-cone-mode: true
+          path: actions
+          sparse-checkout: |
+            .github/actions
 
       # Download Exec
       # Must be done after checkout actions
@@ -50,7 +59,7 @@ jobs:
 
       # GitHub Release
       - name: Create GitHub release
-        uses: kestra-io/actions/composite/github-release@main
+        uses: ./actions/.github/actions/github-release
         if: ${{ startsWith(github.ref, 'refs/tags/v') }}
         env:
           MAKE_LATEST: ${{ steps.is_latest.outputs.latest }}
@@ -69,11 +78,4 @@ jobs:
               "new_version": "${{ github.ref_name }}",
               "github_repository": "${{ github.repository }}",
               "github_actor": "${{ github.actor }}"
-            }
-
-      - name: Merge Release Notes
-        if: ${{ startsWith(github.ref, 'refs/tags/v') }}
-        uses: kestra-io/actions/composite/github-release-note-merge@main
-        env:
-            GITHUB_TOKEN: ${{ secrets.GH_PERSONAL_TOKEN }}
-            RELEASE_TAG: ${{ github.ref_name }}
+            }

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

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

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

@@ -25,11 +25,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout - Current ref
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
 
       # Setup build
       - name: Setup - Build
-        uses: kestra-io/actions/composite/setup-build@main
+        uses: kestra-io/actions/.github/actions/setup-build@main
         id: build
         with:
           java-enabled: true

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

@@ -1,16 +0,0 @@
-name: Pull Request - Delete Docker
-
-on:
-  pull_request:
-    types: [closed]
-
-jobs:
-  publish:
-    name: Pull Request - Delete Docker
-    if: github.repository == 'kestra-io/kestra' # prevent running on forks
-    runs-on: ubuntu-latest
-    steps:
-      - uses: dataaxiom/ghcr-cleanup-action@v1
-        with:
-          package: kestra-pr
-          delete-tags: ${{ github.event.pull_request.number }}

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

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

.github/workflows/workflow-release.yml

@@ -4,7 +4,7 @@ on:
   workflow_dispatch:
     inputs:
       plugin-version:
-        description: "plugins version"
+        description: "Kestra version"
         default: 'LATEST'
         required: false
         type: string
@@ -16,7 +16,7 @@ on:
   workflow_call:
     inputs:
       plugin-version:
-        description: "plugins version"
+        description: "Kestra version"
         default: 'LATEST'
         required: false
         type: string
@@ -57,10 +57,10 @@ jobs:
     name: Publish Docker
     needs: build-artifacts
     uses: ./.github/workflows/workflow-publish-docker.yml
-    if: github.ref == 'refs/heads/develop' || inputs.publish-docker == 'true'
+    if: startsWith(github.ref, 'refs/heads/develop') || github.event.inputs.publish-docker == 'true'
     with:
       force-download-artifact: 'false'
-      plugin-version: ${{ inputs.plugin-version != null && inputs.plugin-version || 'LATEST' }}
+      plugin-version: ${{ github.event.inputs.plugin-version != null && github.event.inputs.plugin-version || 'LATEST' }}
     secrets:
       DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
       DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}

.github/workflows/workflow-test.yml

@@ -27,7 +27,7 @@ jobs:
       ui: ${{ steps.changes.outputs.ui }}
       backend: ${{ steps.changes.outputs.backend }}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
         if: "!startsWith(github.ref, 'refs/tags/v')"
       - uses: dorny/paths-filter@v3
         if: "!startsWith(github.ref, 'refs/tags/v')"
@@ -84,12 +84,14 @@ jobs:
     name: Notify - Slack
     runs-on: ubuntu-latest
     needs: [ frontend, backend ]
+    if: github.event_name == 'schedule'
     steps:
       - name: Notify failed CI
+        id: send-ci-failed
         if: |
-          always() &&
-            (needs.frontend.result != 'success' || needs.backend.result != 'success') &&
-            (github.ref == 'refs/heads/master' || github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop')
-        uses: kestra-io/actions/composite/slack-status@main
-        with:
-          webhook-url: ${{ secrets.SLACK_WEBHOOK_URL }}
+          always() && (needs.frontend.result != 'success' ||
+          needs.backend.result != 'success')
+        uses: kestra-io/actions/.github/actions/send-ci-failed@main
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}

.plugins

@@ -36,7 +36,6 @@
 #plugin-gemini:io.kestra.plugin:plugin-gemini:LATEST
 #plugin-git:io.kestra.plugin:plugin-git:LATEST
 #plugin-github:io.kestra.plugin:plugin-github:LATEST
-#plugin-gitlab:io.kestra.plugin:plugin-gitlab:LATEST
 #plugin-googleworkspace:io.kestra.plugin:plugin-googleworkspace:LATEST
 #plugin-graalvm:io.kestra.plugin:plugin-graalvm:LATEST
 #plugin-graphql:io.kestra.plugin:plugin-graphql:LATEST
@@ -109,17 +108,16 @@
 #plugin-serdes:io.kestra.plugin:plugin-serdes:LATEST
 #plugin-servicenow:io.kestra.plugin:plugin-servicenow:LATEST
 #plugin-sifflet:io.kestra.plugin:plugin-sifflet:LATEST
+#plugin-singer:io.kestra.plugin:plugin-singer:LATEST
 #plugin-soda:io.kestra.plugin:plugin-soda:LATEST
 #plugin-solace:io.kestra.plugin:plugin-solace:LATEST
 #plugin-spark:io.kestra.plugin:plugin-spark:LATEST
 #plugin-sqlmesh:io.kestra.plugin:plugin-sqlmesh:LATEST
-#plugin-supabase:io.kestra.plugin:plugin-supabase:LATEST
 #plugin-surrealdb:io.kestra.plugin:plugin-surrealdb:LATEST
 #plugin-terraform:io.kestra.plugin:plugin-terraform:LATEST
 #plugin-transform:io.kestra.plugin:plugin-transform-grok:LATEST
 #plugin-transform:io.kestra.plugin:plugin-transform-json:LATEST
 #plugin-tika:io.kestra.plugin:plugin-tika:LATEST
-#plugin-trivy:io.kestra.plugin:plugin-trivy:LATEST
 #plugin-weaviate:io.kestra.plugin:plugin-weaviate:LATEST
 #plugin-zendesk:io.kestra.plugin:plugin-zendesk:LATEST
 #plugin-typesense:io.kestra.plugin:plugin-typesense:LATEST

AGENTS.md

@@ -1,305 +0,0 @@
-# Kestra AGENTS.md
-
-This file provides guidance for AI coding agents working on the Kestra project. Kestra is an open-source data orchestration and scheduling platform built with Java (Micronaut) and Vue.js.
-
-## Repository Layout
-
-- **`core/`**: Core Kestra framework and task definitions
-- **`cli/`**: Command-line interface and server implementation
-- **`webserver/`**: REST API server implementation
-- **`ui/`**: Vue.js frontend application
-- **`jdbc-*`**: Database connector modules (H2, MySQL, PostgreSQL)
-- **`script/`**: Script execution engine
-- **`storage-local/`**: Local file storage implementation
-- **`repository-memory/`**: In-memory repository implementation
-- **`runner-memory/`**: In-memory execution runner
-- **`processor/`**: Task processing engine
-- **`model/`**: Data models and Data Transfer Objects
-- **`platform/`**: Platform-specific implementations
-- **`tests/`**: Integration test framework
-- **`e2e-tests/`**: End-to-end testing suite
-
-## Development Environment
-
-### Prerequisites
-
-- Java 21+
-- Node.js 22+ and npm
-- Python 3, pip, and python venv
-- Docker & Docker Compose
-- Gradle (wrapper included)
-
-### Quick Setup with Devcontainer
-
-The easiest way to get started is using the provided devcontainer:
-
-1. Install VSCode Remote Development extension
-2. Run `Dev Containers: Open Folder in Container...` from command palette
-3. Select the Kestra root folder
-4. Wait for Gradle build to complete
-
-### Manual Setup
-
-1. Clone the repository
-2. Run `./gradlew build` to build the backend
-3. Navigate to `ui/` and run `npm install`
-4. Create configuration files as described below
-
-## Configuration Files
-
-### Backend Configuration
-
-Create `cli/src/main/resources/application-override.yml`:
-
-**Local Mode (H2 database):**
-
-```yaml
-micronaut:
-  server:
-    cors:
-      enabled: true
-      configurations:
-        all:
-          allowedOrigins:
-            - http://localhost:5173
-```
-
-**Standalone Mode (PostgreSQL):**
-
-```yaml
-kestra:
-  repository:
-    type: postgres
-  storage:
-    type: local
-    local:
-      base-path: "/app/storage"
-  queue:
-    type: postgres
-  tasks:
-    tmp-dir:
-      path: /tmp/kestra-wd/tmp
-  anonymous-usage-report:
-    enabled: false
-
-datasources:
-  postgres:
-    url: jdbc:postgresql://host.docker.internal:5432/kestra
-    driverClassName: org.postgresql.Driver
-    username: kestra
-    password: k3str4
-
-flyway:
-  datasources:
-    postgres:
-      enabled: true
-      locations:
-        - classpath:migrations/postgres
-      ignore-migration-patterns: "*:missing,*:future"
-      out-of-order: true
-
-micronaut:
-  server:
-    cors:
-      enabled: true
-      configurations:
-        all:
-          allowedOrigins:
-            - http://localhost:5173
-```
-
-### Frontend Configuration
-
-Create `ui/.env.development.local` for environment variables.
-
-## Running the Application
-
-### Backend
-
-- **Local mode**: `./gradlew runLocal` (uses H2 database)
-- **Standalone mode**: Use VSCode Run and Debug with main class `io.kestra.cli.App` and args `server standalone`
-
-### Frontend
-
-- Navigate to `ui/` directory
-- Run `npm run dev` for development server (port 5173)
-- Run `npm run build` for production build
-
-## Building and Testing
-
-### Backend
-
-```bash
-# Build the project
-./gradlew build
-
-# Run tests
-./gradlew test
-
-# Run specific module tests
-./gradlew :core:test
-
-# Clean build
-./gradlew clean build
-```
-
-### Frontend
-
-```bash
-cd ui
-npm install
-npm run test
-npm run lint
-npm run build
-```
-
-### End-to-End Tests
-
-```bash
-# Build and start E2E tests
-./build-and-start-e2e-tests.sh
-
-# Or use the Makefile
-make install
-make install-plugins
-make start-standalone-postgres
-```
-
-## Development Guidelines
-
-### Java Backend
-
-- Use Java 21 features
-- Follow Micronaut framework patterns
-- Add Swagger annotations for API documentation
-- Use annotation processors (enable in IDE)
-- Set `MICRONAUT_ENVIRONMENTS=local,override` for custom config
-- Set `KESTRA_PLUGINS_PATH` for custom plugin loading
-
-### Vue.js Frontend
-
-- Vue 3 with Composition API
-- TypeScript for type safety
-- Vite for build tooling
-- ESLint and Prettier for code quality
-- Component-based architecture in `src/components/`
-
-### Code Style
-
-- Follow `.editorconfig` settings
-- Use 4 spaces for Java, 2 spaces for YAML/JSON/CSS
-- Enable format on save in VSCode
-- Use Prettier for frontend code formatting
-
-## Testing Strategy
-
-### Backend Testing
-
-- Unit tests in `src/test/java/`
-- Integration tests in `tests/` module
-- Use Micronaut test framework
-- Test both local and standalone modes
-
-### Frontend Testing
-- Unit tests with Jest
-- E2E tests with Playwright
-- Component testing with Storybook
-- Run `npm run test:unit` and `npm run test:e2e`
-
-## Plugin Development
-
-### Creating Plugins
-
-- Follow the [Plugin Developer Guide](https://kestra.io/docs/plugin-developer-guide/)
-- Place JAR files in `KESTRA_PLUGINS_PATH`
-- Use the plugin template structure
-- Test with both local and standalone modes
-
-### Plugin Loading
-
-- Set `KESTRA_PLUGINS_PATH` environment variable
-- Use devcontainer mounts for local development
-- Plugins are loaded at startup
-
-## Common Issues and Solutions
-
-### JavaScript Heap Out of Memory
-
-Set `NODE_OPTIONS=--max-old-space-size=4096` environment variable.
-
-### CORS Issues
-
-Ensure backend CORS is configured for `http://localhost:5173` when using frontend dev server.
-
-### Database Connection Issues
-
-- Use `host.docker.internal` instead of `localhost` when connecting from devcontainer
-- Verify PostgreSQL is running and accessible
-- Check database credentials and permissions
-
-### Gradle Build Issues
-
-- Clear Gradle cache: `./gradlew clean`
-- Check Java version compatibility
-- Verify all dependencies are available
-
-## Pull Request Guidelines
-
-### Before Submitting
-
-1. Run all tests: `./gradlew test` and `npm test`
-2. Check code formatting: `./gradlew spotlessCheck`
-3. Verify CORS configuration if changing API
-4. Test both local and standalone modes
-5. Update documentation for user-facing changes
-
-### Commit Messages
-
-- Follow conventional commit format
-- Use present tense ("Add feature" not "Added feature")
-- Reference issue numbers when applicable
-- Keep commits focused and atomic
-
-### Review Checklist
-
-- [ ] All tests pass
-- [ ] Code follows project style guidelines
-- [ ] Documentation is updated
-- [ ] No breaking changes without migration guide
-- [ ] CORS properly configured if API changes
-- [ ] Both local and standalone modes tested
-
-## Useful Commands
-
-```bash
-# Quick development commands
-./gradlew runLocal                    # Start local backend
-./gradlew :ui:build                   # Build frontend
-./gradlew clean build                 # Clean rebuild
-npm run dev                           # Start frontend dev server
-make install                          # Install Kestra locally
-make start-standalone-postgres        # Start with PostgreSQL
-
-# Testing commands
-./gradlew test                        # Run all backend tests
-./gradlew :core:test                  # Run specific module tests
-npm run test                          # Run frontend tests
-npm run lint                          # Lint frontend code
-```
-
-## Getting Help
-
-- Open a [GitHub issue](https://github.com/kestra-io/kestra/issues)
-- Join the [Kestra Slack community](https://kestra.io/slack)
-- Check the [main documentation](https://kestra.io/docs)
-
-## Environment Variables
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `MICRONAUT_ENVIRONMENTS` | Custom config environments | `local,override` |
-| `KESTRA_PLUGINS_PATH` | Path to custom plugins | `/workspaces/kestra/local/plugins` |
-| `NODE_OPTIONS` | Node.js options | `--max-old-space-size=4096` |
-| `JAVA_HOME` | Java installation path | `/usr/java/jdk-21` |
-
-Remember: Always test your changes in both local and standalone modes, and ensure CORS is properly configured for frontend development.

Dockerfile.pr

@@ -1,7 +0,0 @@
-FROM  kestra/kestra:develop
-
-USER root
-
-COPY --chown=kestra:kestra docker /
-
-USER kestra

Makefile

@@ -89,7 +89,7 @@ build-docker: build-exec
 		--compress \
 		--rm \
 		-f ./Dockerfile \
-		--build-arg="APT_PACKAGES=python3 python-is-python3 python3-pip curl jattach" \
+		--build-arg="APT_PACKAGES=python3 python3-venv python-is-python3 python3-pip nodejs npm curl zip unzip jattach" \
 		--build-arg="PYTHON_LIBRARIES=kestra" \
 		-t ${DOCKER_IMAGE}:${VERSION} ${DOCKER_PATH} || exit 1 ;
 

README.md

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

build-and-start-e2e-tests.sh

@@ -7,7 +7,7 @@ set -e
 # run tests on this image
 
 
-LOCAL_IMAGE_VERSION="local-e2e-$(date +%s)"
+LOCAL_IMAGE_VERSION="local-e2e"
 
 echo "Running E2E"
 echo "Start time: $(date '+%Y-%m-%d %H:%M:%S')"
@@ -15,7 +15,6 @@ start_time=$(date +%s)
 
 echo ""
 echo "Building the image for this current repository"
-make clean
 make build-docker VERSION=$LOCAL_IMAGE_VERSION
 
 end_time=$(date +%s)
@@ -33,7 +32,7 @@ echo "npm i"
 npm i
 
 echo 'sh ./run-e2e-tests.sh --kestra-docker-image-to-test "kestra/kestra:$LOCAL_IMAGE_VERSION"'
-./run-e2e-tests.sh --kestra-docker-image-to-test "kestra/kestra:$LOCAL_IMAGE_VERSION"
+sh ./run-e2e-tests.sh --kestra-docker-image-to-test "kestra/kestra:$LOCAL_IMAGE_VERSION"
 
 end_time2=$(date +%s)
 elapsed2=$(( end_time2 - start_time2 ))

build.gradle

@@ -21,7 +21,7 @@ plugins {
 
     // test
     id "com.adarshr.test-logger" version "4.0.0"
-    id "org.sonarqube" version "6.3.1.5724"
+    id "org.sonarqube" version "6.2.0.5505"
     id 'jacoco-report-aggregation'
 
     // helper
@@ -32,12 +32,12 @@ plugins {
 
     // release
     id 'net.researchgate.release' version '3.1.0'
-    id "com.gorylenko.gradle-git-properties" version "2.5.3"
+    id "com.gorylenko.gradle-git-properties" version "2.5.2"
     id 'signing'
     id "com.vanniktech.maven.publish" version "0.34.0"
 
     // OWASP dependency check
-    id "org.owasp.dependencycheck" version "12.1.5" apply false
+    id "org.owasp.dependencycheck" version "12.1.3" apply false
 }
 
 idea {
@@ -168,9 +168,8 @@ allprojects {
 /**********************************************************************************************************************\
  * Test
  **********************************************************************************************************************/
-subprojects {subProj ->
-
-    if (subProj.name != 'platform' && subProj.name != 'jmh-benchmarks') {
+subprojects {
+    if (it.name != 'platform' && it.name != 'jmh-benchmarks') {
         apply plugin: "com.adarshr.test-logger"
 
         java {
@@ -208,13 +207,6 @@ subprojects {subProj ->
 
         test {
             useJUnitPlatform()
-            reports {
-                junitXml.required = true
-                junitXml.outputPerTestCase = true
-                junitXml.mergeReruns = true
-                junitXml.includeSystemErrLog = true;
-                junitXml.outputLocation = layout.buildDirectory.dir("test-results/test")
-            }
 
             // set Xmx for test workers
             maxHeapSize = '4g'
@@ -230,15 +222,6 @@ subprojects {subProj ->
             environment 'SECRET_PASSWORD', "cGFzc3dvcmQ="
             environment 'ENV_TEST1', "true"
             environment 'ENV_TEST2', "Pass by env"
-
-
-            if (subProj.name == 'core' || subProj.name == 'jdbc-h2' || subProj.name == 'jdbc-mysql' || subProj.name == 'jdbc-postgres') {
-                // JUnit 5 parallel settings
-                systemProperty 'junit.jupiter.execution.parallel.enabled', 'true'
-                systemProperty 'junit.jupiter.execution.parallel.mode.default', 'concurrent'
-                systemProperty 'junit.jupiter.execution.parallel.mode.classes.default', 'same_thread'
-                systemProperty 'junit.jupiter.execution.parallel.config.strategy', 'dynamic'
-            }
         }
 
         testlogger {
@@ -637,28 +620,6 @@ subprojects {subProject ->
                 }
             }
         }
-
-        if (subProject.name != 'platform' && subProject.name != 'cli') {
-            // only if a test source set actually exists (avoids empty artifacts)
-            def hasTests = subProject.extensions.findByName('sourceSets')?.findByName('test') != null
-
-            if (hasTests) {
-                // wire the artifact onto every Maven publication of this subproject
-                publishing {
-                    publications {
-                        withType(MavenPublication).configureEach { pub ->
-                            // keep the normal java component + sources/javadoc already configured
-                            pub.artifact(subProject.tasks.named('testsJar').get())
-                        }
-                    }
-                }
-
-                // make sure publish tasks build the tests jar first
-                tasks.matching { it.name.startsWith('publish') }.configureEach {
-                    dependsOn subProject.tasks.named('testsJar')
-                }
-            }
-        }
     }
 }
 

cli/build.gradle

@@ -33,13 +33,8 @@ dependencies {
 
     implementation project(":storage-local")
 
-    // Kestra server components
-    implementation project(":executor")
-    implementation project(":scheduler")
     implementation project(":webserver")
-    implementation project(":worker")
 
     //test
-    testImplementation project(':tests')
     testImplementation "org.wiremock:wiremock-jetty12"
 }

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

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

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

@@ -8,7 +8,7 @@ import io.kestra.core.repositories.FlowRepositoryInterface;
 import io.kestra.core.repositories.LocalFlowRepositoryLoader;
 import io.kestra.core.runners.FlowInputOutput;
 import io.kestra.core.runners.RunnerUtils;
-import io.kestra.cli.StandAloneRunner;
+import io.kestra.core.runners.StandAloneRunner;
 import io.micronaut.context.ApplicationContext;
 import jakarta.inject.Inject;
 import jakarta.validation.ConstraintViolationException;
@@ -72,6 +72,7 @@ public class FlowTestCommand extends AbstractApiCommand {
     public Integer call() throws Exception {
         super.call();
 
+        StandAloneRunner runner = applicationContext.getBean(StandAloneRunner.class);
         LocalFlowRepositoryLoader repositoryLoader = applicationContext.getBean(LocalFlowRepositoryLoader.class);
         FlowRepositoryInterface flowRepository = applicationContext.getBean(FlowRepositoryInterface.class);
         FlowInputOutput flowInputOutput = applicationContext.getBean(FlowInputOutput.class);
@@ -88,7 +89,7 @@ public class FlowTestCommand extends AbstractApiCommand {
             inputs.put(this.inputs.get(i), this.inputs.get(i+1));
         }
 
-        try (StandAloneRunner runner = applicationContext.createBean(StandAloneRunner.class);){
+        try {
             runner.run();
             repositoryLoader.load(tenantService.getTenantId(tenantId), file.toFile());
 
@@ -102,6 +103,8 @@ public class FlowTestCommand extends AbstractApiCommand {
                 (flow, execution) -> flowInputOutput.readExecutionInputs(flow, execution, inputs),
                 Duration.ofHours(1)
             );
+
+            runner.close();
         } catch (ConstraintViolationException e) {
             throw new CommandLine.ParameterException(this.spec.commandLine(), e.getMessage());
         } catch (IOException | TimeoutException e) {

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

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

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

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

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

@@ -2,7 +2,7 @@ package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
 import io.kestra.core.models.ServerType;
-import io.kestra.core.runners.Indexer;
+import io.kestra.core.runners.IndexerInterface;
 import io.kestra.core.utils.Await;
 import io.micronaut.context.ApplicationContext;
 import jakarta.inject.Inject;
@@ -29,7 +29,7 @@ public class IndexerCommand extends AbstractServerCommand {
     public Integer call() throws Exception {
         super.call();
 
-        Indexer indexer = applicationContext.getBean(Indexer.class);
+        IndexerInterface indexer = applicationContext.getBean(IndexerInterface.class);
         indexer.run();
 
         Await.until(() -> !this.applicationContext.isRunning());

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

@@ -2,7 +2,7 @@ package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
 import io.kestra.core.models.ServerType;
-import io.kestra.scheduler.AbstractScheduler;
+import io.kestra.core.schedulers.AbstractScheduler;
 import io.kestra.core.utils.Await;
 import io.micronaut.context.ApplicationContext;
 import jakarta.inject.Inject;

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

@@ -6,8 +6,8 @@ import io.kestra.cli.services.TenantIdSelectorService;
 import io.kestra.core.contexts.KestraContext;
 import io.kestra.core.models.ServerType;
 import io.kestra.core.repositories.LocalFlowRepositoryLoader;
-import io.kestra.cli.StandAloneRunner;
-import io.kestra.executor.SkipExecutionService;
+import io.kestra.core.runners.StandAloneRunner;
+import io.kestra.core.services.SkipExecutionService;
 import io.kestra.core.services.StartExecutorService;
 import io.kestra.core.utils.Await;
 import io.micronaut.context.ApplicationContext;
@@ -109,27 +109,26 @@ public class StandAloneCommand extends AbstractServerCommand {
             }
         }
 
-        try (StandAloneRunner standAloneRunner = applicationContext.getBean(StandAloneRunner.class)) {
+        StandAloneRunner standAloneRunner = applicationContext.getBean(StandAloneRunner.class);
 
-            if (this.workerThread == 0) {
-                standAloneRunner.setWorkerEnabled(false);
-            } else {
-                standAloneRunner.setWorkerThread(this.workerThread);
-            }
-
-            if (this.indexerDisabled) {
-                standAloneRunner.setIndexerEnabled(false);
-            }
-
-            standAloneRunner.run();
-
-            if (fileWatcher != null) {
-                fileWatcher.startListeningFromConfig();
-            }
-
-            Await.until(() -> !this.applicationContext.isRunning());
+        if (this.workerThread == 0) {
+            standAloneRunner.setWorkerEnabled(false);
+        } else {
+            standAloneRunner.setWorkerThread(this.workerThread);
         }
 
+        if (this.indexerDisabled) {
+            standAloneRunner.setIndexerEnabled(false);
+        }
+
+        standAloneRunner.run();
+
+        if (fileWatcher != null) {
+            fileWatcher.startListeningFromConfig();
+        }
+
+        Await.until(() -> !this.applicationContext.isRunning());
+
         return 0;
     }
 }

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

@@ -2,7 +2,7 @@ package io.kestra.cli.commands.servers;
 
 import com.google.common.collect.ImmutableMap;
 import io.kestra.core.models.ServerType;
-import io.kestra.core.runners.Indexer;
+import io.kestra.core.runners.IndexerInterface;
 import io.kestra.core.utils.Await;
 import io.kestra.core.utils.ExecutorsUtils;
 import io.micronaut.context.ApplicationContext;
@@ -54,7 +54,7 @@ public class WebServerCommand extends AbstractServerCommand {
         if (!indexerDisabled) {
             log.info("Starting an embedded indexer, this can be disabled by using `--no-indexer`.");
             poolExecutor = executorsUtils.cachedThreadPool("webserver-indexer");
-            poolExecutor.execute(applicationContext.getBean(Indexer.class));
+            poolExecutor.execute(applicationContext.getBean(IndexerInterface.class));
             shutdownHook(false, () -> poolExecutor.shutdown());
         }
 

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

@@ -10,21 +10,24 @@ import io.kestra.core.repositories.FlowRepositoryInterface;
 import io.kestra.core.services.FlowListenersInterface;
 import io.kestra.core.services.PluginDefaultService;
 import io.micronaut.context.annotation.Requires;
+import io.micronaut.context.annotation.Value;
 import io.micronaut.scheduling.io.watch.FileWatchConfiguration;
 import jakarta.annotation.Nullable;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
 import jakarta.validation.ConstraintViolationException;
-import java.util.concurrent.CopyOnWriteArrayList;
 import lombok.extern.slf4j.Slf4j;
 
 import java.io.IOException;
 import java.nio.charset.Charset;
 import java.nio.file.*;
 import java.nio.file.attribute.BasicFileAttributes;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 
+import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
+
 @Singleton
 @Slf4j
 @Requires(property = "micronaut.io.watch.enabled", value = "true")
@@ -46,9 +49,13 @@ public class FileChangedEventListener {
     @Inject
     protected FlowListenersInterface flowListeners;
 
+    @Nullable
+    @Value("${micronaut.io.watch.tenantId}")
+    private String tenantId;
+
     FlowFilesManager flowFilesManager;
 
-    private List<FlowWithPath> flows = new CopyOnWriteArrayList<>();
+    private List<FlowWithPath> flows = new ArrayList<>();
 
     private boolean isStarted = false;
 
@@ -106,6 +113,8 @@ public class FileChangedEventListener {
     }
 
     public void startListening(List<Path> paths) throws IOException, InterruptedException {
+        String tenantId = this.tenantId != null ? this.tenantId : MAIN_TENANT;
+
         for (Path path : paths) {
             path.register(watchService, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY);
         }
@@ -148,7 +157,7 @@ public class FileChangedEventListener {
                                             flows.add(FlowWithPath.of(flow.get(), filePath.toString()));
                                         }
 
-                                        flowFilesManager.createOrUpdateFlow(GenericFlow.fromYaml(getTenantIdFromPath(filePath), content));
+                                        flowFilesManager.createOrUpdateFlow(GenericFlow.fromYaml(tenantId, content));
                                         log.info("Flow {} from file {} has been created or modified", flow.get().getId(), entry);
                                     }
 
@@ -192,6 +201,8 @@ public class FileChangedEventListener {
     }
 
     private void loadFlowsFromFolder(Path folder) {
+        String tenantId = this.tenantId != null ? this.tenantId : MAIN_TENANT;
+
         try {
             Files.walkFileTree(folder, new SimpleFileVisitor<Path>() {
                 @Override
@@ -211,7 +222,7 @@ public class FileChangedEventListener {
 
                         if (flow.isPresent() && flows.stream().noneMatch(flowWithPath -> flowWithPath.uidWithoutRevision().equals(flow.get().uidWithoutRevision()))) {
                             flows.add(FlowWithPath.of(flow.get(), file.toString()));
-                            flowFilesManager.createOrUpdateFlow(GenericFlow.fromYaml(getTenantIdFromPath(file), content));
+                            flowFilesManager.createOrUpdateFlow(GenericFlow.fromYaml(tenantId, content));
                         }
                     }
                     return FileVisitResult.CONTINUE;
@@ -235,8 +246,10 @@ public class FileChangedEventListener {
     }
 
     private Optional<FlowWithSource> parseFlow(String content, Path entry) {
+        String tenantId = this.tenantId != null ? this.tenantId : MAIN_TENANT;
+
         try {
-            FlowWithSource flow = pluginDefaultService.parseFlowWithAllDefaults(getTenantIdFromPath(entry), content, false);
+            FlowWithSource flow = pluginDefaultService.parseFlowWithAllDefaults(tenantId, content, false);
             modelValidator.validate(flow);
             return Optional.of(flow);
         } catch (ConstraintViolationException | FlowProcessingException e) {
@@ -260,10 +273,4 @@ public class FileChangedEventListener {
     private Path buildPath(FlowInterface flow) {
         return fileWatchConfiguration.getPaths().getFirst().resolve(flow.uidWithoutRevision() + ".yml");
     }
-
-    private String getTenantIdFromPath(Path path) {
-        // FIXME there is probably a bug here when a tenant has '_' in its name,
-        //  a valid tenant name is defined with following regex: "^[a-z0-9][a-z0-9_-]*"
-        return path.getFileName().toString().split("_")[0];
-    }
 }

cli/src/main/resources/application.yml

@@ -18,10 +18,6 @@ micronaut:
       root:
         paths: classpath:root
         mapping: /**
-  codec:
-    json:
-      additional-types:
-        - application/scim+json
   server:
     max-request-size: 10GB
     multipart:
@@ -82,19 +78,8 @@ micronaut:
       type: scheduled
       core-pool-size: 1
 
+  # Disable OpenTelemetry metrics by default, users that need it must enable it and configure the collector URL.
   metrics:
-    binders:
-      retry:
-        enabled: true
-      netty:
-        queues:
-          enabled: true
-        bytebuf-allocators:
-          enabled: true
-        channels:
-          enabled: true
-
-    # Disable OpenTelemetry metrics by default, users that need it must enable it and configure the collector URL.
     export:
       otlp:
         enabled: false
@@ -107,8 +92,6 @@ jackson:
   serialization-inclusion: non_null
   deserialization:
     FAIL_ON_UNKNOWN_PROPERTIES: false
-  mapper:
-    ACCEPT_CASE_INSENSITIVE_ENUMS: true
 
 endpoints:
   all:
@@ -117,10 +100,6 @@ endpoints:
     sensitive: false
   health:
     details-visible: ANONYMOUS
-    disk-space:
-      enabled: false
-    discovery-client:
-      enabled: false
   loggers:
     write-sensitive: false
   env:
@@ -154,46 +133,12 @@ kestra:
   tutorial-flows:
     # Automatically loads all tutorial flows at startup.
     enabled: true
-
   retries:
     attempts: 5
     multiplier: 2.0
     delay: 1s
     maxDelay: ""
 
-  server:
-    basic-auth:
-      # These URLs will not be authenticated, by default we open some of the Micronaut default endpoints but not all for security reasons
-      open-urls:
-        - "/ping"
-        - "/api/v1/executions/webhook/"
-        - "/api/v1/main/executions/webhook/"
-        - "/api/v1/*/executions/webhook/"
-
-    preview:
-      initial-rows: 100
-      max-rows: 5000
-
-    # The expected time for this server to complete all its tasks before initiating a graceful shutdown.
-    terminationGracePeriod: 5m
-    workerTaskRestartStrategy: AFTER_TERMINATION_GRACE_PERIOD
-    # Configuration for Liveness and Heartbeat mechanism between servers.
-    liveness:
-      enabled: true
-      # The expected time between liveness probe.
-      interval: 10s
-      # The timeout used to detect service failures.
-      timeout: 1m
-      # The time to wait before executing a liveness probe.
-      initialDelay: 1m
-      # The expected time between service heartbeats.
-      heartbeatInterval: 3s
-    service:
-      purge:
-        initial-delay: 1h
-        fixed-delay: 1d
-        retention: 30d
-
   jdbc:
     queues:
       min-poll-interval: 25ms
@@ -205,7 +150,7 @@ kestra:
       fixed-delay: 1h
       retention: 7d
       types:
-        - type: io.kestra.core.models.executions.LogEntry
+        - type : io.kestra.core.models.executions.LogEntry
           retention: 1h
         - type: io.kestra.core.models.executions.MetricEntry
           retention: 1h
@@ -237,12 +182,37 @@ kestra:
   traces:
     root: DISABLED
 
-  ui-anonymous-usage-report:
-    enabled: true
-
+  server:
+    basic-auth:
+      # These URLs will not be authenticated, by default we open some of the Micronaut default endpoints but not all for security reasons
+      open-urls:
+        - "/ping"
+        - "/api/v1/executions/webhook/"
+    preview:
+      initial-rows: 100
+      max-rows: 5000
+    # The expected time for this server to complete all its tasks before initiating a graceful shutdown.
+    terminationGracePeriod: 5m
+    workerTaskRestartStrategy: AFTER_TERMINATION_GRACE_PERIOD
+    # Configuration for Liveness and Heartbeat mechanism between servers.
+    liveness:
+      enabled: true
+      # The expected time between liveness probe.
+      interval: 10s
+      # The timeout used to detect service failures.
+      timeout: 1m
+      # The time to wait before executing a liveness probe.
+      initialDelay: 1m
+      # The expected time between service heartbeats.
+      heartbeatInterval: 3s
+    service:
+      purge:
+        initial-delay: 1h
+        fixed-delay: 1d
+        retention: 30d
   anonymous-usage-report:
     enabled: true
-    uri: https://api.kestra.io/v1/reports/server-events
+    uri: https://api.kestra.io/v1/reports/usages
     initial-delay: 5m
     fixed-delay: 1h
 

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

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

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

@@ -1,14 +1,13 @@
 package io.kestra.cli.services;
 
 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 +17,8 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
-import org.junitpioneer.jupiter.RetryingTest;
 
+import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static io.kestra.core.utils.Rethrow.throwRunnable;
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -57,11 +56,10 @@ class FileChangedEventListenerTest {
         }
     }
 
-    @Test
+    @RetryingTest(5) // Flaky on CI but always pass locally
     void test() throws IOException, TimeoutException {
-        var tenant = TestsUtils.randomTenant(FileChangedEventListenerTest.class.getSimpleName(), "test");
         // remove the flow if it already exists
-        flowRepository.findByIdWithSource(tenant, "io.kestra.tests.watch", "myflow").ifPresent(flow -> flowRepository.delete(flow));
+        flowRepository.findByIdWithSource(MAIN_TENANT, "io.kestra.tests.watch", "myflow").ifPresent(flow -> flowRepository.delete(flow));
 
         // create a basic flow
         String flow = """
@@ -73,33 +71,30 @@ class FileChangedEventListenerTest {
                 type: io.kestra.plugin.core.log.Log
                 message: Hello World! 🚀
             """;
-
-        GenericFlow genericFlow = GenericFlow.fromYaml(tenant, flow);
-        Files.write(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"), flow.getBytes());
+        Files.write(Path.of(FILE_WATCH + "/myflow.yaml"), flow.getBytes());
         Await.until(
-            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "myflow").isPresent(),
+            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "myflow").isPresent(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );
-        Flow myflow = flowRepository.findById(tenant, "io.kestra.tests.watch", "myflow").orElseThrow();
+        Flow myflow = flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "myflow").orElseThrow();
         assertThat(myflow.getTasks()).hasSize(1);
         assertThat(myflow.getTasks().getFirst().getId()).isEqualTo("hello");
         assertThat(myflow.getTasks().getFirst().getType()).isEqualTo("io.kestra.plugin.core.log.Log");
 
         // delete the flow
-        Files.delete(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"));
+        Files.delete(Path.of(FILE_WATCH + "/myflow.yaml"));
         Await.until(
-            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "myflow").isEmpty(),
+            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "myflow").isEmpty(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );
     }
 
-    @RetryingTest(2)
+    @RetryingTest(5) // Flaky on CI but always pass locally
     void testWithPluginDefault() throws IOException, TimeoutException {
-        var tenant = TestsUtils.randomTenant(FileChangedEventListenerTest.class.getName(), "testWithPluginDefault");
         // remove the flow if it already exists
-        flowRepository.findByIdWithSource(tenant, "io.kestra.tests.watch", "pluginDefault").ifPresent(flow -> flowRepository.delete(flow));
+        flowRepository.findByIdWithSource(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").ifPresent(flow -> flowRepository.delete(flow));
 
         // create a flow with plugin default
         String pluginDefault = """
@@ -115,22 +110,21 @@ class FileChangedEventListenerTest {
                 values:
                   message: Hello World!
             """;
-        GenericFlow genericFlow = GenericFlow.fromYaml(tenant, pluginDefault);
-        Files.write(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"), pluginDefault.getBytes());
+        Files.write(Path.of(FILE_WATCH + "/plugin-default.yaml"), pluginDefault.getBytes());
         Await.until(
-            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "pluginDefault").isPresent(),
+            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").isPresent(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );
-        Flow pluginDefaultFlow = flowRepository.findById(tenant, "io.kestra.tests.watch", "pluginDefault").orElseThrow();
+        Flow pluginDefaultFlow = flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").orElseThrow();
         assertThat(pluginDefaultFlow.getTasks()).hasSize(1);
         assertThat(pluginDefaultFlow.getTasks().getFirst().getId()).isEqualTo("helloWithDefault");
         assertThat(pluginDefaultFlow.getTasks().getFirst().getType()).isEqualTo("io.kestra.plugin.core.log.Log");
 
         // delete both files
-        Files.delete(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"));
+        Files.delete(Path.of(FILE_WATCH + "/plugin-default.yaml"));
         Await.until(
-            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "pluginDefault").isEmpty(),
+            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").isEmpty(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );

core/build.gradle

@@ -37,15 +37,15 @@ dependencies {
     implementation 'nl.basjes.gitignore:gitignore-reader'
     implementation group: 'dev.failsafe', name: 'failsafe'
     implementation 'com.github.ben-manes.caffeine:caffeine'
-    implementation 'com.github.ksuid:ksuid:1.1.4'
+    implementation 'com.github.ksuid:ksuid:1.1.3'
     api 'org.apache.httpcomponents.client5:httpclient5'
 
     // plugins
     implementation 'org.apache.maven.resolver:maven-resolver-impl'
-    implementation 'org.apache.maven.resolver:maven-resolver-supplier-mvn3'
+    implementation 'org.apache.maven.resolver:maven-resolver-supplier'
     implementation 'org.apache.maven.resolver:maven-resolver-connector-basic'
     implementation 'org.apache.maven.resolver:maven-resolver-transport-file'
-    implementation 'org.apache.maven.resolver:maven-resolver-transport-apache'
+    implementation 'org.apache.maven.resolver:maven-resolver-transport-http'
 
     // scheduler
     implementation group: 'com.cronutils', name: 'cron-utils'
@@ -63,10 +63,6 @@ dependencies {
         exclude group: 'com.fasterxml.jackson.core'
     }
 
-    // micrometer
-    implementation "io.micronaut.micrometer:micronaut-micrometer-observation"
-    implementation 'io.micrometer:micrometer-java21'
-
     // test
     testAnnotationProcessor project(':processor')
     testImplementation project(':tests')
@@ -74,9 +70,6 @@ dependencies {
     testImplementation project(':repository-memory')
     testImplementation project(':runner-memory')
     testImplementation project(':storage-local')
-    testImplementation project(':worker')
-    testImplementation project(':scheduler')
-    testImplementation project(':executor')
 
     testImplementation "io.micronaut:micronaut-http-client"
     testImplementation "io.micronaut:micronaut-http-server-netty"
@@ -84,7 +77,7 @@ dependencies {
 
     testImplementation "org.testcontainers:testcontainers:1.21.3"
     testImplementation "org.testcontainers:junit-jupiter:1.21.3"
-    testImplementation "org.bouncycastle:bcpkix-jdk18on"
+    testImplementation "org.bouncycastle:bcpkix-jdk18on:1.81"
 
     testImplementation "org.wiremock:wiremock-jetty12"
 }

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

@@ -53,8 +53,6 @@ import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
 
-import static io.kestra.core.docs.AbstractClassDocumentation.flattenWithoutType;
-import static io.kestra.core.docs.AbstractClassDocumentation.required;
 import static io.kestra.core.serializers.JacksonMapper.MAP_TYPE_REFERENCE;
 
 @Singleton
@@ -94,16 +92,12 @@ public class JsonSchemaGenerator {
     }
 
     public <T> Map<String, Object> schemas(Class<? extends T> cls, boolean arrayOf, List<String> allowedPluginTypes) {
-        return this.schemas(cls, arrayOf, allowedPluginTypes, false);
-    }
-
-    public <T> Map<String, Object> schemas(Class<? extends T> cls, boolean arrayOf, List<String> allowedPluginTypes, boolean withOutputs) {
         SchemaGeneratorConfigBuilder builder = new SchemaGeneratorConfigBuilder(
             SchemaVersion.DRAFT_7,
             OptionPreset.PLAIN_JSON
         );
 
-        this.build(builder, true, allowedPluginTypes, withOutputs);
+        this.build(builder, true, allowedPluginTypes);
 
         SchemaGeneratorConfig schemaGeneratorConfig = builder.build();
 
@@ -128,13 +122,12 @@ public class JsonSchemaGenerator {
             if (jsonNode instanceof ObjectNode clazzSchema && clazzSchema.get("required") instanceof ArrayNode requiredPropsNode && clazzSchema.get("properties") instanceof ObjectNode properties) {
                 List<String> requiredFieldValues = StreamSupport.stream(requiredPropsNode.spliterator(), false)
                     .map(JsonNode::asText)
-                    .collect(Collectors.toList());
+                    .toList();
 
                 properties.fields().forEachRemaining(e -> {
                     int indexInRequiredArray = requiredFieldValues.indexOf(e.getKey());
                     if (indexInRequiredArray != -1 && e.getValue() instanceof ObjectNode valueNode && valueNode.has("default")) {
                         requiredPropsNode.remove(indexInRequiredArray);
-                        requiredFieldValues.remove(indexInRequiredArray);
                     }
                 });
 
@@ -255,10 +248,6 @@ public class JsonSchemaGenerator {
     }
 
     protected void build(SchemaGeneratorConfigBuilder builder, boolean draft7, List<String> allowedPluginTypes) {
-        this.build(builder, draft7, allowedPluginTypes, false);
-    }
-
-    protected void build(SchemaGeneratorConfigBuilder builder, boolean draft7, List<String> allowedPluginTypes, boolean withOutputs) {
 //        builder.withObjectMapper(builder.getObjectMapper().configure(SerializationFeature.WRITE_DURATIONS_AS_TIMESTAMPS, false));
         builder
             .with(new JakartaValidationModule(
@@ -440,13 +429,6 @@ public class JsonSchemaGenerator {
                     if (pluginAnnotation.beta()) {
                         collectedTypeAttributes.put("$beta", true);
                     }
-
-                    if (withOutputs) {
-                        Map<String, Object> outputsSchema = this.outputs(null, scope.getType().getErasedType());
-                        collectedTypeAttributes.set("outputs", context.getGeneratorConfig().createObjectNode().pojoNode(
-                            flattenWithoutType(AbstractClassDocumentation.properties(outputsSchema), required(outputsSchema))
-                        ));
-                    }
                 }
 
                 // handle deprecated tasks

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

@@ -36,7 +36,6 @@ public class Plugin {
     private List<PluginElementMetadata> appBlocks;
     private List<PluginElementMetadata> charts;
     private List<PluginElementMetadata> dataFilters;
-    private List<PluginElementMetadata> dataFiltersKPI;
     private List<PluginElementMetadata> logExporters;
     private List<PluginElementMetadata> additionalPlugins;
     private List<PluginSubGroup.PluginCategory> categories;
@@ -97,7 +96,6 @@ public class Plugin {
         plugin.appBlocks = filterAndGetTypeWithMetadata(registeredPlugin.getAppBlocks(), packagePredicate);
         plugin.charts = filterAndGetTypeWithMetadata(registeredPlugin.getCharts(), packagePredicate);
         plugin.dataFilters = filterAndGetTypeWithMetadata(registeredPlugin.getDataFilters(), packagePredicate);
-        plugin.dataFiltersKPI = filterAndGetTypeWithMetadata(registeredPlugin.getDataFiltersKPI(), packagePredicate);
         plugin.logExporters = filterAndGetTypeWithMetadata(registeredPlugin.getLogExporters(), packagePredicate);
         plugin.additionalPlugins = filterAndGetTypeWithMetadata(registeredPlugin.getAdditionalPlugins(), packagePredicate);
 

core/src/main/java/io/kestra/core/endpoints/SchedulerEndpoint.java

@@ -1,9 +1,9 @@
-package io.kestra.scheduler.endpoint;
+package io.kestra.core.endpoints;
 
 import io.kestra.core.models.flows.FlowWithException;
 import io.kestra.core.models.triggers.AbstractTrigger;
 import io.kestra.core.models.triggers.Trigger;
-import io.kestra.scheduler.AbstractScheduler;
+import io.kestra.core.schedulers.AbstractScheduler;
 import io.micronaut.context.annotation.Requires;
 import io.micronaut.management.endpoint.annotation.Endpoint;
 import io.micronaut.management.endpoint.annotation.Read;

core/src/main/java/io/kestra/core/endpoints/WorkerEndpoint.java

@@ -1,4 +1,4 @@
-package io.kestra.worker.endpoint;
+package io.kestra.core.endpoints;
 
 import io.kestra.core.models.triggers.AbstractTrigger;
 import io.kestra.core.runners.WorkerTask;
@@ -11,18 +11,18 @@ import lombok.Builder;
 import lombok.Getter;
 import io.kestra.core.models.executions.TaskRun;
 import io.kestra.core.models.tasks.Task;
-import io.kestra.worker.DefaultWorker;
+import io.kestra.core.runners.Worker;
 
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
-
+import java.util.stream.Collectors;
 import jakarta.inject.Inject;
 
 @Endpoint(id = "worker", defaultSensitive = false)
 @Requires(property = "kestra.server-type", pattern = "(WORKER|STANDALONE)")
 public class WorkerEndpoint {
     @Inject
-    DefaultWorker worker;
+    Worker worker;
 
     @Read
     public WorkerEndpointResult running() throws Exception {

core/src/main/java/io/kestra/core/events/CrudEvent.java

@@ -3,88 +3,30 @@ package io.kestra.core.events;
 import io.micronaut.core.annotation.Nullable;
 import io.micronaut.http.HttpRequest;
 import io.micronaut.http.context.ServerRequestContext;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
 
-import java.util.Objects;
-
+@AllArgsConstructor
 @Getter
 public class CrudEvent<T> {
-    private final T model;
+    T model;
     @Nullable
-    private final T previousModel;
-    private final CrudEventType type;
-    private final HttpRequest<?> request;
-    
-    /**
-     * Static helper method for creating a new {@link CrudEventType#UPDATE} CrudEvent.
-     *
-     * @param model the new created model.
-     * @param <T>   type of the model.
-     * @return the new {@link CrudEvent}.
-     */
-    public static <T> CrudEvent<T> create(T model) {
-        Objects.requireNonNull(model, "Can't create CREATE event with a null model");
-        return new CrudEvent<>(model, null, CrudEventType.CREATE);
-    }
-    
-    /**
-     * Static helper method for creating a new {@link CrudEventType#DELETE} CrudEvent.
-     *
-     * @param model the deleted model.
-     * @param <T>   type of the model.
-     * @return the new {@link CrudEvent}.
-     */
-    public static <T> CrudEvent<T> delete(T model) {
-        Objects.requireNonNull(model, "Can't create DELETE event with a null model");
-        return new CrudEvent<>(null, model, CrudEventType.DELETE);
-    }
-    
-    /**
-     * Static helper method for creating a new CrudEvent.
-     *
-     * @param before the model before the update.
-     * @param after  the model after the update.
-     * @param <T>   type of the model.
-     * @return the new {@link CrudEvent}.
-     */
-    public static <T> CrudEvent<T> of(T before, T after) {
-        
-        if (before == null && after == null) {
-            throw new IllegalArgumentException("Both before and after cannot be null");
-        }
-        
-        if (before == null) {
-            return create(after);
-        }
-        
-        if (after == null) {
-            return delete(before);
-        }
-        
-        return new CrudEvent<>(after, before, CrudEventType.UPDATE);
-    }
-    
-    /**
-     * @deprecated use the static factory methods.
-     */
-    @Deprecated
+    T previousModel;
+    CrudEventType type;
+    HttpRequest<?> request;
+
     public CrudEvent(T model, CrudEventType type) {
-        this(
-            CrudEventType.DELETE.equals(type) ? null : model,
-            CrudEventType.DELETE.equals(type) ? model : null, 
-            type, 
-            ServerRequestContext.currentRequest().orElse(null)
-        );
+        this.model = model;
+        this.type = type;
+        this.previousModel = null;
+        this.request = ServerRequestContext.currentRequest().orElse(null);
     }
 
     public CrudEvent(T model, T previousModel, CrudEventType type) {
-        this(model, previousModel, type, ServerRequestContext.currentRequest().orElse(null));
-    }
-    
-    public CrudEvent(T model, T previousModel, CrudEventType type, HttpRequest<?> request) {
         this.model = model;
         this.previousModel = previousModel;
         this.type = type;
-        this.request = request;
+        this.request = ServerRequestContext.currentRequest().orElse(null);
     }
+
 }

core/src/main/java/io/kestra/core/http/client/HttpClient.java

@@ -6,24 +6,16 @@ import io.kestra.core.http.HttpRequest;
 import io.kestra.core.http.HttpResponse;
 import io.kestra.core.http.client.apache.*;
 import io.kestra.core.http.client.configurations.HttpConfiguration;
-import io.kestra.core.runners.DefaultRunContext;
 import io.kestra.core.runners.RunContext;
 import io.kestra.core.serializers.JacksonMapper;
-import io.micrometer.common.KeyValues;
-import io.micrometer.core.instrument.binder.httpcomponents.hc5.ApacheHttpClientContext;
-import io.micrometer.core.instrument.binder.httpcomponents.hc5.DefaultApacheHttpClientObservationConvention;
-import io.micrometer.core.instrument.binder.httpcomponents.hc5.ObservationExecChainHandler;
-import io.micrometer.observation.ObservationRegistry;
 import io.micronaut.http.MediaType;
 import jakarta.annotation.Nullable;
 import lombok.Builder;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.ArrayUtils;
-import org.apache.commons.lang3.StringUtils;
 import org.apache.hc.client5.http.ContextBuilder;
 import org.apache.hc.client5.http.auth.*;
 import org.apache.hc.client5.http.config.ConnectionConfig;
-import org.apache.hc.client5.http.impl.ChainElement;
 import org.apache.hc.client5.http.impl.DefaultAuthenticationStrategy;
 import org.apache.hc.client5.http.impl.auth.BasicCredentialsProvider;
 import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
@@ -38,6 +30,7 @@ import org.apache.hc.core5.http.io.HttpClientResponseHandler;
 import org.apache.hc.core5.http.io.entity.EntityUtils;
 import org.apache.hc.core5.ssl.SSLContexts;
 import org.apache.hc.core5.util.Timeout;
+import org.codehaus.plexus.util.StringUtils;
 
 import java.io.Closeable;
 import java.io.IOException;
@@ -57,16 +50,11 @@ public class HttpClient implements Closeable {
     private transient CloseableHttpClient client;
     private final RunContext runContext;
     private final HttpConfiguration configuration;
-    private ObservationRegistry observationRegistry;
 
     @Builder
     public HttpClient(RunContext runContext, @Nullable HttpConfiguration configuration) throws IllegalVariableEvaluationException {
         this.runContext = runContext;
         this.configuration = configuration == null ? HttpConfiguration.builder().build() : configuration;
-        if (runContext instanceof DefaultRunContext defaultRunContext) {
-            this.observationRegistry = defaultRunContext.getApplicationContext().findBean(ObservationRegistry.class).orElse(null);
-        }
-
         this.client = this.createClient();
     }
 
@@ -79,13 +67,6 @@ public class HttpClient implements Closeable {
             .disableDefaultUserAgent()
             .setUserAgent("Kestra");
 
-        if (observationRegistry != null) {
-            // micrometer, must be placed before the retry strategy (see https://docs.micrometer.io/micrometer/reference/reference/httpcomponents.html#_retry_strategy_considerations)
-            builder.addExecInterceptorAfter(ChainElement.RETRY.name(), "micrometer",
-                new ObservationExecChainHandler(observationRegistry, new CustomApacheHttpClientObservationConvention())
-            );
-        }
-
         // logger
         if (this.configuration.getLogs() != null && this.configuration.getLogs().length > 0) {
             if (ArrayUtils.contains(this.configuration.getLogs(), HttpConfiguration.LoggingType.REQUEST_HEADERS) ||
@@ -316,14 +297,4 @@ public class HttpClient implements Closeable {
             this.client.close();
         }
     }
-
-    public static class CustomApacheHttpClientObservationConvention extends DefaultApacheHttpClientObservationConvention {
-        @Override
-        public KeyValues getLowCardinalityKeyValues(ApacheHttpClientContext context) {
-            return KeyValues.concat(
-                super.getLowCardinalityKeyValues(context),
-                KeyValues.of("type", "core-client")
-            );
-        }
-    }
 }

core/src/main/java/io/kestra/core/metrics/MeterRegistryBinderFactory.java

@@ -1,34 +0,0 @@
-package io.kestra.core.metrics;
-
-import io.micrometer.core.instrument.binder.jvm.JvmThreadDeadlockMetrics;
-import io.micrometer.java21.instrument.binder.jdk.VirtualThreadMetrics;
-import io.micronaut.configuration.metrics.annotation.RequiresMetrics;
-import io.micronaut.context.annotation.Bean;
-import io.micronaut.context.annotation.Factory;
-import io.micronaut.context.annotation.Primary;
-import io.micronaut.context.annotation.Requires;
-import jakarta.inject.Singleton;
-
-import static io.micronaut.configuration.metrics.micrometer.MeterRegistryFactory.MICRONAUT_METRICS_BINDERS;
-import static io.micronaut.core.util.StringUtils.FALSE;
-
-@Factory
-@RequiresMetrics
-
-public class MeterRegistryBinderFactory {
-    @Bean
-    @Primary
-    @Singleton
-    @Requires(property = MICRONAUT_METRICS_BINDERS + ".jvm.enabled", notEquals = FALSE)
-    public VirtualThreadMetrics virtualThreadMetrics() {
-        return new VirtualThreadMetrics();
-    }
-
-    @Bean
-    @Primary
-    @Singleton
-    @Requires(property = MICRONAUT_METRICS_BINDERS + ".jvm.enabled", notEquals = FALSE)
-    public JvmThreadDeadlockMetrics threadDeadlockMetricsMetrics() {
-        return new JvmThreadDeadlockMetrics();
-    }
-}

core/src/main/java/io/kestra/core/metrics/MetricRegistry.java

@@ -6,6 +6,7 @@ import io.kestra.core.models.tasks.Task;
 import io.kestra.core.models.triggers.AbstractTrigger;
 import io.kestra.core.models.triggers.TriggerContext;
 import io.kestra.core.runners.*;
+import io.kestra.core.schedulers.SchedulerExecutionWithTrigger;
 import io.micrometer.core.instrument.*;
 import io.micrometer.core.instrument.binder.MeterBinder;
 import io.micrometer.core.instrument.search.Search;
@@ -394,6 +395,19 @@ public class MetricRegistry {
         return triggerContext.getTenantId() == null ? baseTags : ArrayUtils.addAll(baseTags, TAG_TENANT_ID, triggerContext.getTenantId());
     }
 
+    /**
+     * Return tags for current {@link SchedulerExecutionWithTrigger}.
+     *
+     * @param schedulerExecutionWithTrigger the current SchedulerExecutionWithTrigger
+     * @return tags to apply to metrics
+     */
+    public String[] tags(SchedulerExecutionWithTrigger schedulerExecutionWithTrigger, String... tags) {
+        return ArrayUtils.addAll(
+            this.tags(schedulerExecutionWithTrigger.getExecution()),
+            tags
+        );
+    }
+
     /**
      * Return tags for current {@link ExecutionKilled}
      *

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

@@ -2,13 +2,12 @@ package io.kestra.core.models;
 
 import io.kestra.core.utils.MapUtils;
 import jakarta.annotation.Nullable;
-import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
 
 import java.util.*;
-import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
-public record Label(@NotEmpty String key, @NotEmpty String value) {
+public record Label(@NotNull String key, @NotNull String value) {
     public static final String SYSTEM_PREFIX = "system.";
 
     // system labels
@@ -42,7 +41,7 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
     public static Map<String, String> toMap(@Nullable List<Label> labels) {
         if (labels == null || labels.isEmpty()) return Collections.emptyMap();
         return labels.stream()
-            .filter(label -> label.value() != null && !label.value().isEmpty() && label.key() != null && !label.key().isEmpty())
+            .filter(label -> label.value() != null && label.key() != null)
             // using an accumulator in case labels with the same key exists: the second is kept
             .collect(Collectors.toMap(Label::key, Label::value, (first, second) -> second, LinkedHashMap::new));
     }
@@ -57,7 +56,6 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
     public static List<Label> deduplicate(@Nullable List<Label> labels) {
         if (labels == null || labels.isEmpty()) return Collections.emptyList();
         return toMap(labels).entrySet().stream()
-            .filter(getEntryNotEmptyPredicate())
             .map(entry -> new Label(entry.getKey(), entry.getValue()))
             .collect(Collectors.toCollection(ArrayList::new));
     }
@@ -72,7 +70,6 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
         if (map == null || map.isEmpty()) return List.of();
         return map.entrySet()
             .stream()
-            .filter(getEntryNotEmptyPredicate())
             .map(entry -> new Label(entry.getKey(), entry.getValue()))
             .toList();
     }
@@ -91,14 +88,4 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
         }
         return map;
     }
-
-    /**
-     * Provides predicate for not empty entries.
-     *
-     * @return The non-empty filter
-     */
-    public static Predicate<Map.Entry<String, String>> getEntryNotEmptyPredicate() {
-        return entry -> entry.getKey() != null && !entry.getKey().isEmpty() &&
-            entry.getValue() != null && !entry.getValue().isEmpty();
-    }
 }

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

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

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

@@ -139,12 +139,6 @@ public record QueryFilter(
                 return List.of(Op.EQUALS, Op.NOT_EQUALS, Op.CONTAINS, Op.STARTS_WITH, Op.ENDS_WITH, Op.IN, Op.NOT_IN);
             }
         },
-        EXECUTION_ID("executionId") {
-            @Override
-            public List<Op> supportedOp() {
-                return List.of(Op.EQUALS, Op.NOT_EQUALS, Op.CONTAINS, Op.STARTS_WITH, Op.ENDS_WITH, Op.IN, Op.NOT_IN);
-            }
-        },
         CHILD_FILTER("childFilter") {
             @Override
             public List<Op> supportedOp() {
@@ -219,7 +213,7 @@ public record QueryFilter(
             @Override
             public List<Field> supportedField() {
                 return List.of(Field.QUERY, Field.SCOPE, Field.NAMESPACE, Field.START_DATE,
-                    Field.END_DATE, Field.FLOW_ID, Field.TRIGGER_ID, Field.MIN_LEVEL, Field.EXECUTION_ID
+                    Field.END_DATE, Field.FLOW_ID, Field.TRIGGER_ID, Field.MIN_LEVEL
                 );
             }
         },
@@ -254,7 +248,19 @@ public record QueryFilter(
          *
          * @return List of {@code ResourceField} with resource names, fields, and operations.
          */
-        
+        public static List<ResourceField> asResourceList() {
+            return Arrays.stream(values())
+                .map(Resource::toResourceField)
+                .toList();
+        }
+
+        private static ResourceField toResourceField(Resource resource) {
+            List<FieldOp> fieldOps = resource.supportedField().stream()
+                .map(Resource::toFieldInfo)
+                .toList();
+            return new ResourceField(resource.name().toLowerCase(), fieldOps);
+        }
+
         private static FieldOp toFieldInfo(Field field) {
             List<Operation> operations = field.supportedOp().stream()
                 .map(Resource::toOperation)
@@ -267,6 +273,9 @@ public record QueryFilter(
         }
     }
 
+    public record ResourceField(String name, List<FieldOp> fields) {
+    }
+
     public record FieldOp(String name, String value, List<Operation> operations) {
     }
 

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

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

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

@@ -62,7 +62,6 @@ public record ServiceUsage(
 
         List<DailyServiceStatistics> statistics = Arrays
             .stream(ServiceType.values())
-            .filter(it -> !it.equals(ServiceType.INVALID))
             .map(type -> of(from, to, repository, type, interval))
             .toList();
         return new ServiceUsage(statistics);

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

@@ -0,0 +1,74 @@
+package io.kestra.core.models.collectors;
+
+import io.kestra.core.models.ServerType;
+import io.micronaut.core.annotation.Introspected;
+import jakarta.annotation.Nullable;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.experimental.SuperBuilder;
+import lombok.extern.jackson.Jacksonized;
+
+import java.time.Instant;
+import java.time.ZoneId;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@SuperBuilder(toBuilder = true)
+@Getter
+@Jacksonized
+@Introspected
+@AllArgsConstructor
+public class Usage {
+    @NotNull
+    private final String uuid;
+
+    @NotNull
+    private final String startUuid;
+
+    @NotNull
+    private final String instanceUuid;
+
+    @NotNull
+    private final ServerType serverType;
+
+    @NotNull
+    private final String version;
+
+    @NotNull
+    private final ZoneId zoneId;
+
+    @Nullable
+    private final String uri;
+
+    @Nullable
+    private final Set<String> environments;
+
+    @NotNull
+    private final Instant startTime;
+
+    @Valid
+    private final HostUsage host;
+
+    @Valid
+    private final ConfigurationUsage configurations;
+
+    @Valid
+    private final List<PluginUsage> plugins;
+
+    @Valid
+    private final FlowUsage flows;
+
+    @Valid
+    private final ExecutionUsage executions;
+
+    @Valid
+    @Nullable
+    private ServiceUsage services;
+
+    @Valid
+    @Nullable
+    private List<PluginMetric> pluginMetrics;
+}

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

@@ -441,28 +441,6 @@ public class Execution implements DeletedInterface, TenantInterface {
         @Nullable List<ResolvedTask> resolvedErrors,
         @Nullable List<ResolvedTask> resolvedFinally,
         TaskRun parentTaskRun
-    ) {
-        return findTaskDependingFlowState(resolvedTasks, resolvedErrors, resolvedFinally, parentTaskRun, null);
-    }
-
-    /**
-     * Determine if the current execution is on error &amp; normal tasks
-     * <p>
-     * if the current have errors, return tasks from errors if not, return the normal tasks
-     *
-     * @param resolvedTasks normal tasks
-     * @param resolvedErrors errors tasks
-     * @param resolvedFinally finally tasks
-     * @param parentTaskRun the parent task
-     * @param terminalState the parent task terminal state
-     * @return the flow we need to follow
-     */
-    public List<ResolvedTask> findTaskDependingFlowState(
-        List<ResolvedTask> resolvedTasks,
-        @Nullable List<ResolvedTask> resolvedErrors,
-        @Nullable List<ResolvedTask> resolvedFinally,
-        TaskRun parentTaskRun,
-        @Nullable State.Type terminalState
     ) {
         resolvedTasks = removeDisabled(resolvedTasks);
         resolvedErrors = removeDisabled(resolvedErrors);
@@ -476,15 +454,10 @@ public class Execution implements DeletedInterface, TenantInterface {
             return resolvedFinally == null ? Collections.emptyList() : resolvedFinally;
         }
 
-        // check if the parent task should fail, and there is error tasks so we start them
-        if (errorsFlow.isEmpty() && terminalState == State.Type.FAILED) {
-            return resolvedErrors == null ? resolvedFinally == null ? Collections.emptyList() : resolvedFinally : resolvedErrors;
-        }
-
-        // Check if flow has failed tasks
+        // Check if flow has failed task
         if (!errorsFlow.isEmpty() || this.hasFailed(resolvedTasks, parentTaskRun)) {
             // Check if among the failed task, they will be retried
-            if (!this.hasFailedNoRetry(resolvedTasks, parentTaskRun) && terminalState != State.Type.FAILED) {
+            if (!this.hasFailedNoRetry(resolvedTasks, parentTaskRun)) {
                 return Collections.emptyList();
             }
 
@@ -693,11 +666,6 @@ public class Execution implements DeletedInterface, TenantInterface {
 
     public State.Type guessFinalState(List<ResolvedTask> currentTasks, TaskRun parentTaskRun,
         boolean allowFailure, boolean allowWarning) {
-        return guessFinalState(currentTasks, parentTaskRun, allowFailure, allowWarning, State.Type.SUCCESS);
-    }
-
-    public State.Type guessFinalState(List<ResolvedTask> currentTasks, TaskRun parentTaskRun,
-                                      boolean allowFailure, boolean allowWarning, State.Type terminalState) {
         List<TaskRun> taskRuns = this.findTaskRunByTasks(currentTasks, parentTaskRun);
         var state = this
             .findLastByState(taskRuns, State.Type.KILLED)
@@ -714,7 +682,7 @@ public class Execution implements DeletedInterface, TenantInterface {
                 .findLastByState(taskRuns, State.Type.PAUSED)
                 .map(taskRun -> taskRun.getState().getCurrent())
             )
-            .orElse(terminalState);
+            .orElse(State.Type.SUCCESS);
 
         if (state == State.Type.FAILED && allowFailure) {
             if (allowWarning) {
@@ -865,18 +833,20 @@ public class Execution implements DeletedInterface, TenantInterface {
      * @param e the exception raise
      * @return new taskRun with updated attempt with logs
      */
-    private FailedTaskRunWithLog lastAttemptsTaskRunForFailedExecution(TaskRun taskRun, TaskRunAttempt lastAttempt, Exception e) {
-        TaskRun failed = taskRun
-            .withAttempts(
-                Stream
-                    .concat(
-                        taskRun.getAttempts().stream().limit(taskRun.getAttempts().size() - 1),
-                        Stream.of(lastAttempt.getState().isFailed() ? lastAttempt : lastAttempt.withState(State.Type.FAILED))
-                    )
-                    .toList()
-            );
+    private FailedTaskRunWithLog lastAttemptsTaskRunForFailedExecution(TaskRun taskRun,
+        TaskRunAttempt lastAttempt, Exception e) {
         return new FailedTaskRunWithLog(
-            failed.getState().isFailed() ? failed : failed.withState(State.Type.FAILED),
+            taskRun
+                .withAttempts(
+                    Stream
+                        .concat(
+                            taskRun.getAttempts().stream().limit(taskRun.getAttempts().size() - 1),
+                            Stream.of(lastAttempt
+                                .withState(State.Type.FAILED))
+                        )
+                        .toList()
+                )
+                .withState(State.Type.FAILED),
             RunContextLogger.logEntries(loggingEventFromException(e), LogEntry.of(taskRun, kind))
         );
     }
@@ -1070,16 +1040,6 @@ public class Execution implements DeletedInterface, TenantInterface {
         return result;
     }
 
-    /**
-     * Find all children of this {@link TaskRun}.
-     */
-    public List<TaskRun> findChildren(TaskRun parentTaskRun) {
-        return taskRunList.stream()
-            .filter(taskRun -> parentTaskRun.getId().equals(taskRun.getParentTaskRunId()))
-            .toList();
-    }
-
-
     public List<String> findParentsValues(TaskRun taskRun, boolean withCurrent) {
         return (withCurrent ?
             Stream.concat(findParents(taskRun).stream(), Stream.of(taskRun)) :

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

@@ -62,7 +62,6 @@ public abstract class AbstractFlow implements FlowInterface {
     @JsonSerialize(using = ListOrMapOfLabelSerializer.class)
     @JsonDeserialize(using = ListOrMapOfLabelDeserializer.class)
     @Schema(implementation = Object.class, oneOf = {List.class, Map.class})
-    @Valid
     List<Label> labels;
 
     @Schema(additionalProperties = Schema.AdditionalPropertiesValue.TRUE)

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

@@ -122,7 +122,7 @@ public class Flow extends AbstractFlow implements HasUID {
     AbstractRetry retry;
 
     @Valid
-    @PluginProperty
+    @PluginProperty(beta = true)
     List<SLA> sla;
 
     public Stream<String> allTypes() {

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

@@ -4,7 +4,6 @@ import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.triggers.Trigger;
 import io.kestra.core.utils.IdUtils;
 import lombok.AllArgsConstructor;
-import lombok.EqualsAndHashCode;
 import lombok.Getter;
 
 import java.util.Optional;
@@ -58,7 +57,6 @@ public interface FlowId {
 
     @Getter
     @AllArgsConstructor
-    @EqualsAndHashCode
     class Default implements FlowId {
         private final String tenantId;
         private final String namespace;

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

@@ -4,8 +4,6 @@ import com.fasterxml.jackson.annotation.JsonSetter;
 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;
@@ -18,8 +16,6 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 
-import java.util.function.Function;
-
 @SuppressWarnings("deprecation")
 @SuperBuilder
 @Getter
@@ -82,7 +78,7 @@ public abstract class Input<T> implements Data {
     @Schema(
         title = "The default value to use if no value is specified."
     )
-    Property<T> defaults;
+    T defaults;
 
     @Schema(
         title = "The display name of the input."

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

@@ -43,11 +43,4 @@ public class Output implements Data {
     Type type;
 
     String displayName;
-    
-    /**
-     * Specifies whether the output is required or not.
-     * <p>
-     * By default, an output is always required.
-     */
-    Boolean required;
 }

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

@@ -116,7 +116,7 @@ public class State {
     }
 
     public Instant maxDate() {
-        if (this.histories.isEmpty()) {
+        if (this.histories.size() == 0) {
             return Instant.now();
         }
 
@@ -124,7 +124,7 @@ public class State {
     }
 
     public Instant minDate() {
-        if (this.histories.isEmpty()) {
+        if (this.histories.size() == 0) {
             return Instant.now();
         }
 
@@ -173,11 +173,6 @@ public class State {
         return this.current.isBreakpoint();
     }
 
-    @JsonIgnore
-    public boolean isQueued() {
-        return this.current.isQueued();
-    }
-
     @JsonIgnore
     public boolean isRetrying() {
         return this.current.isRetrying();
@@ -211,14 +206,6 @@ public class State {
         return this.histories.get(this.histories.size() - 2).state.isPaused();
     }
 
-    /**
-     * Return true if the execution has failed, then was restarted.
-     * This is to disambiguate between a RESTARTED after PAUSED and RESTARTED after FAILED state.
-     */
-    public boolean failedThenRestarted() {
-       return this.current ==  Type.RESTARTED && this.histories.get(this.histories.size() - 2).state.isFailed();
-    }
-
     @Introspected
     public enum Type {
         CREATED,
@@ -277,10 +264,6 @@ public class State {
             return this == Type.KILLED;
         }
 
-        public boolean isQueued(){
-            return this == Type.QUEUED;
-        }
-
         /**
          * @return states that are terminal to an execution
          */

core/src/main/java/io/kestra/core/models/flows/input/InputAndValue.java

@@ -6,21 +6,19 @@ import jakarta.validation.ConstraintViolationException;
 import jakarta.validation.constraints.NotNull;
 
 /**
- * Represents an input along with its associated value and validation state.
+ * Represents a
  *
- * @param input     The {@link Input} definition of the flow.
- * @param value     The provided value for the input.
- * @param enabled   {@code true} if the input is enabled; {@code false} otherwise.
- * @param isDefault {@code true} if the provided value is the default; {@code false} otherwise.
- * @param exception The validation exception, if the input value is invalid; {@code null} otherwise.
+ * @param input     The flow's {@link Input}.
+ * @param value     The flow's input value/data.
+ * @param enabled   Specify whether the input is enabled.
+ * @param exception The input validation exception.
  */
 public record InputAndValue(
     Input<?> input,
     Object value,
     boolean enabled,
-    boolean isDefault,
     ConstraintViolationException exception) {
-    
+
     /**
      * Creates a new {@link InputAndValue} instance.
      *
@@ -28,6 +26,6 @@ public record InputAndValue(
      * @param value The value.
      */
     public InputAndValue(@NotNull Input<?> input, @Nullable Object value) {
-        this(input, value, true, false, null);
+        this(input, value, true, null);
     }
 }

core/src/main/java/io/kestra/core/models/flows/input/MultiselectInput.java

@@ -3,7 +3,6 @@ package io.kestra.core.models.flows.input;
 import io.kestra.core.models.flows.Input;
 import io.kestra.core.models.flows.RenderableInput;
 import io.kestra.core.models.flows.Type;
-import io.kestra.core.models.property.Property;
 import io.kestra.core.models.validations.ManualConstraintViolation;
 import io.kestra.core.validations.Regex;
 import io.swagger.v3.oas.annotations.media.Schema;
@@ -14,7 +13,6 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 
-import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
@@ -58,23 +56,6 @@ public class MultiselectInput extends Input<List<String>> implements ItemTypeInt
     @Builder.Default
     Boolean allowCustomValue = false;
 
-    @Schema(
-        title = "Whether the first value of the multi-select should be selected by default."
-    )
-    @NotNull
-    @Builder.Default
-    Boolean autoSelectFirst = false;
-
-    @Override
-    public Property<List<String>> getDefaults() {
-        Property<List<String>> baseDefaults = super.getDefaults();
-        if (baseDefaults == null && autoSelectFirst && !Optional.ofNullable(values).map(Collection::isEmpty).orElse(true)) {
-            return Property.ofValue(List.of(values.getFirst()));
-        }
-
-        return baseDefaults;
-    }
-
     @Override
     public void validate(List<String> inputs) throws ConstraintViolationException {
         if (values != null && options != null) {
@@ -119,7 +100,6 @@ public class MultiselectInput extends Input<List<String>> implements ItemTypeInt
                 .dependsOn(getDependsOn())
                 .itemType(getItemType())
                 .displayName(getDisplayName())
-                .autoSelectFirst(getAutoSelectFirst())
                 .build();
         }
         return this;

core/src/main/java/io/kestra/core/models/flows/input/SelectInput.java

@@ -2,7 +2,6 @@ package io.kestra.core.models.flows.input;
 
 import io.kestra.core.models.flows.Input;
 import io.kestra.core.models.flows.RenderableInput;
-import io.kestra.core.models.property.Property;
 import io.kestra.core.models.validations.ManualConstraintViolation;
 import io.kestra.core.validations.Regex;
 import io.swagger.v3.oas.annotations.media.Schema;
@@ -13,7 +12,6 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 
-import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
@@ -48,23 +46,6 @@ public class SelectInput extends Input<String> implements RenderableInput {
     @Builder.Default
     Boolean isRadio = false;
 
-    @Schema(
-        title = "Whether the first value of the select should be selected by default."
-    )
-    @NotNull
-    @Builder.Default
-    Boolean autoSelectFirst = false;
-
-    @Override
-    public Property<String> getDefaults() {
-        Property<String> baseDefaults = super.getDefaults();
-        if (baseDefaults == null && autoSelectFirst && !Optional.ofNullable(values).map(Collection::isEmpty).orElse(true)) {
-            return Property.ofValue(values.getFirst());
-        }
-
-        return baseDefaults;
-    }
-
     @Override
     public void validate(String input) throws ConstraintViolationException {
         if (!values.contains(input) && this.getRequired()) {
@@ -97,7 +78,6 @@ public class SelectInput extends Input<String> implements RenderableInput {
                 .dependsOn(getDependsOn())
                 .displayName(getDisplayName())
                 .isRadio(getIsRadio())
-                .autoSelectFirst(getAutoSelectFirst())
                 .build();
         }
         return this;

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

@@ -68,19 +68,6 @@ 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
-     */
-    public Property<T> skipCache() {
-        return Property.ofExpression(expression);
-    }
 
     /**
      * Build a new Property object with a value already set.<br>
@@ -145,8 +132,8 @@ public class Property<T> {
      *
      * @see io.kestra.core.runners.RunContextProperty#as(Class)
      */
-    public static <T> T as(Property<T> property, PropertyContext context, Class<T> clazz) throws IllegalVariableEvaluationException {
-        return as(property, context, clazz, Map.of());
+    public static <T> T as(Property<T> property, RunContext runContext, Class<T> clazz) throws IllegalVariableEvaluationException {
+        return as(property, runContext, clazz, Map.of());
     }
 
     /**
@@ -156,9 +143,9 @@ public class Property<T> {
      *
      * @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 {
+    public static <T> T as(Property<T> property, RunContext runContext, Class<T> clazz, Map<String, Object> variables) throws IllegalVariableEvaluationException {
         if (property.value == null) {
-            String rendered =  context.render(property.expression, variables);
+            String rendered =  runContext.render(property.expression, variables);
             property.value = MAPPER.convertValue(rendered, clazz);
         }
 
@@ -172,8 +159,8 @@ public class Property<T> {
      *
      * @see io.kestra.core.runners.RunContextProperty#asList(Class)
      */
-    public static <T, I> T asList(Property<T> property, PropertyContext context, Class<I> itemClazz) throws IllegalVariableEvaluationException {
-        return asList(property, context, itemClazz, Map.of());
+    public static <T, I> T asList(Property<T> property, RunContext runContext, Class<I> itemClazz) throws IllegalVariableEvaluationException {
+        return asList(property, runContext, itemClazz, Map.of());
     }
 
     /**
@@ -184,7 +171,7 @@ public class Property<T> {
      * @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 {
+    public static <T, I> T asList(Property<T> property, RunContext runContext, Class<I> itemClazz, Map<String, Object> variables) throws IllegalVariableEvaluationException {
         if (property.value == null) {
             JavaType type = MAPPER.getTypeFactory().constructCollectionLikeType(List.class, itemClazz);
             try {
@@ -192,7 +179,7 @@ public class Property<T> {
                 // We need to detect if the expression is already a list or if it's a pebble expression (for eg. referencing a variable containing a list).
                 // Doing that allows us to, if it's an expression, first render then read it as a list.
                 if (trimmedExpression.startsWith("{{") && trimmedExpression.endsWith("}}")) {
-                    property.value = MAPPER.readValue(context.render(property.expression, variables), type);
+                    property.value = MAPPER.readValue(runContext.render(property.expression, variables), type);
                 }
                 // Otherwise, if it's already a list, we read it as a list first then render it from run context which handle list rendering by rendering each item of the list
                 else {
@@ -200,9 +187,9 @@ public class Property<T> {
                     property.value = (T) asRawList.stream()
                         .map(throwFunction(item -> {
                             if (item instanceof String str) {
-                                return MAPPER.convertValue(context.render(str, variables), itemClazz);
+                                return MAPPER.convertValue(runContext.render(str, variables), itemClazz);
                             } else if (item instanceof Map map) {
-                                return MAPPER.convertValue(context.render(map, variables), itemClazz);
+                                return MAPPER.convertValue(runContext.render(map, variables), itemClazz);
                             }
                             return item;
                         }))

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

@@ -1,38 +0,0 @@
-package io.kestra.core.models.property;
-
-import io.kestra.core.exceptions.IllegalVariableEvaluationException;
-import io.kestra.core.runners.VariableRenderer;
-
-import java.util.Map;
-
-/**
- * Contextual object for rendering properties.
- * 
- * @see Property
- */
-public interface PropertyContext {
-    
-    String render(String inline, Map<String, Object> variables) throws IllegalVariableEvaluationException;
-    
-    Map<String, Object> render(Map<String, Object> inline, Map<String, Object> variables) throws IllegalVariableEvaluationException;
-    
-    /**
-     * Static helper method for creating a new {@link PropertyContext} from a given {@link VariableRenderer}.
-     *
-     * @param renderer the {@link VariableRenderer}.
-     * @return a new {@link PropertyContext}.
-     */
-    static PropertyContext create(final VariableRenderer renderer) {
-        return new PropertyContext() {
-            @Override
-            public String render(String inline, Map<String, Object> variables) throws IllegalVariableEvaluationException {
-                return renderer.render(inline, variables);
-            }
-            
-            @Override
-            public Map<String, Object> render(Map<String, Object> inline, Map<String, Object> variables) throws IllegalVariableEvaluationException {
-                return renderer.render(inline, variables);
-            }
-        };
-    }
-}

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

@@ -185,6 +185,34 @@ public class Trigger extends TriggerContext implements HasUID {
             .build();
     }
 
+    public static Trigger update(Trigger currentTrigger, Trigger newTrigger, ZonedDateTime nextExecutionDate) throws Exception {
+        Trigger updated = currentTrigger;
+
+        // If a backfill is created, we update the currentTrigger
+        // and set the nextExecutionDate() as the previous one
+        if (newTrigger.getBackfill() != null) {
+            updated = currentTrigger.toBuilder()
+                .backfill(
+                    newTrigger
+                        .getBackfill()
+                        .toBuilder()
+                        .end(newTrigger.getBackfill().getEnd() != null ? newTrigger.getBackfill().getEnd() : ZonedDateTime.now())
+                        .currentDate(
+                            newTrigger.getBackfill().getStart()
+                        )
+                        .previousNextExecutionDate(
+                            currentTrigger.getNextExecutionDate())
+                        .build())
+                .build();
+        }
+
+        return updated.toBuilder()
+            .nextExecutionDate(newTrigger.getDisabled() ?
+                null : nextExecutionDate)
+            .disabled(newTrigger.getDisabled())
+            .build();
+    }
+
     public Trigger resetExecution(Flow flow, Execution execution, ConditionContext conditionContext) {
         boolean disabled = this.getStopAfter() != null ? this.getStopAfter().contains(execution.getState().getCurrent()) : this.getDisabled();
         if (!disabled) {
@@ -194,7 +222,6 @@ public class Trigger extends TriggerContext implements HasUID {
             }
             // If trigger is a schedule and execution ended after the next execution date
             else if (abstractTrigger instanceof Schedule schedule &&
-                this.getNextExecutionDate() != null &&
                 execution.getState().getEndDate().get().isAfter(this.getNextExecutionDate().toInstant())
             ) {
                 RecoverMissedSchedules recoverMissedSchedules = Optional.ofNullable(schedule.getRecoverMissedSchedules())
@@ -248,22 +275,27 @@ public class Trigger extends TriggerContext implements HasUID {
             .build();
     }
 
-    public Trigger withBackfill(final Backfill backfill) {
-        Trigger updated = this;
-        // If a backfill is created, we update the trigger
+    public Trigger initBackfill(Trigger newTrigger) {
+        // If a backfill is created, we update the currentTrigger
         // and set the nextExecutionDate() as the previous one
-        if (backfill != null) {
-            updated = this.toBuilder()
+        if (newTrigger.getBackfill() != null) {
+
+            return this.toBuilder()
                 .backfill(
-                    backfill
+                    newTrigger
+                        .getBackfill()
                         .toBuilder()
-                        .end(backfill.getEnd() != null ? backfill.getEnd() : ZonedDateTime.now())
-                        .currentDate(backfill.getStart())
-                        .previousNextExecutionDate(this.getNextExecutionDate())
+                        .end(newTrigger.getBackfill().getEnd() != null ? newTrigger.getBackfill().getEnd() : ZonedDateTime.now())
+                        .currentDate(
+                            newTrigger.getBackfill().getStart()
+                        )
+                        .previousNextExecutionDate(
+                            this.getNextExecutionDate())
                         .build())
                 .build();
         }
-        return updated;
+
+        return this;
     }
 
     // if the next date is after the backfill end, we remove the backfill

core/src/main/java/io/kestra/core/models/triggers/multipleflows/MultipleCondition.java

@@ -3,6 +3,7 @@ package io.kestra.core.models.triggers.multipleflows;
 import io.kestra.core.exceptions.InternalException;
 import io.kestra.core.models.conditions.Condition;
 import io.kestra.core.models.conditions.ConditionContext;
+import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.triggers.TimeWindow;
 import io.kestra.core.utils.Rethrow;
 import org.slf4j.Logger;
@@ -23,7 +24,7 @@ public interface MultipleCondition extends Rethrow.PredicateChecked<ConditionCon
 
     /**
      * This conditions will only validate previously calculated value on
-     * io.kestra.executor.FlowTriggerService#computeExecutionsFromFlowTriggers(Execution, List, Optional) and {@link MultipleConditionStorageInterface#save(List)} by the executor.
+     * {@link io.kestra.core.services.FlowTriggerService#computeExecutionsFromFlowTriggers(Execution, List, Optional)}} and {@link MultipleConditionStorageInterface#save(List)} by the executor.
      * The real validation is done here.
      */
     @Override

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

@@ -43,7 +43,7 @@ public class DefaultPluginRegistry implements PluginRegistry {
         static final DefaultPluginRegistry INSTANCE = new DefaultPluginRegistry();
     }
 
-    protected final Map<PluginIdentifier, PluginClassAndMetadata<? extends Plugin>> pluginClassByIdentifier = new ConcurrentHashMap<>();
+    private final Map<PluginIdentifier, PluginClassAndMetadata<? extends Plugin>> pluginClassByIdentifier = new ConcurrentHashMap<>();
     private final Map<PluginBundleIdentifier, RegisteredPlugin> plugins = new ConcurrentHashMap<>();
     private final PluginScanner scanner = new PluginScanner(DefaultPluginRegistry.class.getClassLoader());
     private final AtomicBoolean initialized = new AtomicBoolean(false);
@@ -56,7 +56,7 @@ public class DefaultPluginRegistry implements PluginRegistry {
      *
      * @return the {@link DefaultPluginRegistry}.
      */
-    public synchronized static DefaultPluginRegistry getOrCreate() {
+    public static DefaultPluginRegistry getOrCreate() {
         DefaultPluginRegistry instance = LazyHolder.INSTANCE;
         if (!instance.isInitialized()) {
             instance.init();
@@ -74,7 +74,7 @@ public class DefaultPluginRegistry implements PluginRegistry {
     /**
      * Initializes the registry by loading all core plugins.
      */
-    protected synchronized void init() {
+    protected void init() {
         if (initialized.compareAndSet(false, true)) {
             register(scanner.scan());
         }
@@ -103,13 +103,11 @@ public class DefaultPluginRegistry implements PluginRegistry {
      */
     @Override
     public void registerIfAbsent(final Path pluginPath) {
-        long start = System.currentTimeMillis();
         if (isPluginPathValid(pluginPath) && !isPluginPathScanned(pluginPath)) {
             List<RegisteredPlugin> scanned = scanner.scan(pluginPath);
             scanned.forEach(this::register);
             scannedPluginPaths.add(pluginPath);
         }
-        log.debug("Registered if absent plugins from path {} in {} ms", pluginPath, System.currentTimeMillis() - start);
     }
 
     private boolean isPluginPathScanned(final Path pluginPath) {
@@ -121,12 +119,10 @@ public class DefaultPluginRegistry implements PluginRegistry {
      */
     @Override
     public void register(final Path pluginPath) {
-        long start = System.currentTimeMillis();
         if (isPluginPathValid(pluginPath)) {
             List<RegisteredPlugin> scanned = scanner.scan(pluginPath);
             scanned.forEach(this::register);
         }
-        log.debug("Registered plugins from path {} in {} ms", pluginPath, System.currentTimeMillis() - start);
     }
 
     /**
@@ -195,28 +191,21 @@ public class DefaultPluginRegistry implements PluginRegistry {
      */
     public void register(final RegisteredPlugin plugin) {
         final PluginBundleIdentifier identifier = PluginBundleIdentifier.of(plugin);
-        // Skip registration if the same plugin already exists in the registry.
-        final RegisteredPlugin existing = plugins.get(identifier);
-        if (existing != null && existing.crc32() == plugin.crc32()) {
-            return; // same plugin already registered
+
+        // Skip registration if plugin-bundle already exists in the registry.
+        if (containsPluginBundle(identifier)) {
+            return;
         }
 
         lock.lock();
         try {
-            if (existing != null) {
-                unregister(List.of(existing));
-            }
             plugins.put(PluginBundleIdentifier.of(plugin), plugin);
-            registerAll(getPluginClassesByIdentifier(plugin));
+            pluginClassByIdentifier.putAll(getPluginClassesByIdentifier(plugin));
         } finally {
             lock.unlock();
         }
     }
 
-    protected void registerAll(Map<PluginIdentifier, PluginClassAndMetadata<? extends Plugin>> plugins) {
-        pluginClassByIdentifier.putAll(plugins);
-    }
-
     @SuppressWarnings("unchecked")
     protected Map<PluginIdentifier, PluginClassAndMetadata<? extends Plugin>> getPluginClassesByIdentifier(final RegisteredPlugin plugin) {
         Map<PluginIdentifier, PluginClassAndMetadata<? extends Plugin>> classes = new HashMap<>();

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

@@ -6,12 +6,6 @@ import lombok.Getter;
 import lombok.ToString;
 
 import java.net.URL;
-import java.nio.ByteBuffer;
-import java.nio.charset.StandardCharsets;
-import java.util.Enumeration;
-import java.util.jar.JarEntry;
-import java.util.jar.JarFile;
-import java.util.zip.CRC32;
 
 @AllArgsConstructor
 @Getter
@@ -20,59 +14,4 @@ import java.util.zip.CRC32;
 public class ExternalPlugin {
     private final URL location;
     private final URL[] resources;
-    private volatile Long crc32; // lazy-val
-    
-    public ExternalPlugin(URL location, URL[] resources) {
-        this.location = location;
-        this.resources = resources;
-    }
-    
-    public Long getCrc32() {
-        if (this.crc32 == null) {
-            synchronized (this) {
-                if (this.crc32 == null) {
-                    this.crc32 = computeJarCrc32(location);
-                }
-            }
-        }
-        return crc32;
-    }
-    
-    /**
-     * Compute a CRC32 of the JAR File without reading the whole file
-     *
-     * @param location of the JAR File.
-     * @return the CRC32 of {@code -1} if the checksum can't be computed.
-     */
-    private static long computeJarCrc32(final URL location) {
-        CRC32 crc = new CRC32();
-        try (JarFile jar = new JarFile(location.toURI().getPath(), false)) {
-            Enumeration<JarEntry> entries = jar.entries();
-            byte[] buffer = new byte[Long.BYTES]; // reusable buffer to avoid re-allocation
-            
-            while (entries.hasMoreElements()) {
-                JarEntry entry = entries.nextElement();
-                crc.update(entry.getName().getBytes(StandardCharsets.UTF_8));
-                updateCrc32WithLong(crc, buffer, entry.getSize());
-                updateCrc32WithLong(crc, buffer, entry.getCrc());
-            }
-            
-            return crc.getValue();
-        } catch (Exception e) {
-            return -1;
-        }
-    }
-    
-    private static void updateCrc32WithLong(CRC32 crc32, byte[] reusable, long val) {
-        // fast long -> byte conversion
-        reusable[0] = (byte) (val >>> 56);
-        reusable[1] = (byte) (val >>> 48);
-        reusable[2] = (byte) (val >>> 40);
-        reusable[3] = (byte) (val >>> 32);
-        reusable[4] = (byte) (val >>> 24);
-        reusable[5] = (byte) (val >>> 16);
-        reusable[6] = (byte) (val >>> 8);
-        reusable[7] = (byte) val;
-        crc32.update(reusable);;
-    }
 }

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

@@ -46,7 +46,6 @@ public class PluginClassLoader extends URLClassLoader {
         + "|dev.failsafe"
         + "|reactor"
         + "|io.opentelemetry"
-        + "|io.netty"
         + ")\\..*$");
 
     private final ClassLoader parent;

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

@@ -2,14 +2,10 @@ package io.kestra.core.plugins;
 
 import io.kestra.core.models.Plugin;
 
-import java.net.URL;
-import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Predicate;
-import java.util.zip.CRC32;
-import java.util.zip.Checksum;
 
 /**
  * Registry for managing all Kestra's {@link Plugin}.
@@ -127,24 +123,4 @@ public interface PluginRegistry {
      * @return {@code true} if supported. Otherwise {@code false}.
      */
     boolean isVersioningSupported();
-    
-    /**
-     * Computes a CRC32 hash value representing the current content of the plugin registry.
-     *
-     * @return a {@code long} containing the CRC32 checksum value, serving as a compact
-     *         representation of the registry's content
-     */
-    default long hash() {
-        Checksum crc32 = new CRC32();
-        
-        for (RegisteredPlugin plugin : plugins()) {
-            Optional.ofNullable(plugin.getExternalPlugin())
-                .map(ExternalPlugin::getCrc32)
-                .ifPresent(checksum -> {
-                    byte[] bytes = ByteBuffer.allocate(Long.BYTES).putLong(checksum).array();
-                    crc32.update(bytes, 0, bytes.length);
-                });
-        }
-        return crc32.getValue();
-    }
 }

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

@@ -5,15 +5,11 @@ import lombok.extern.slf4j.Slf4j;
 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
-import java.nio.ByteBuffer;
 import java.nio.file.DirectoryStream;
 import java.nio.file.Files;
 import java.nio.file.InvalidPathException;
 import java.nio.file.Path;
 import java.util.*;
-import java.util.jar.JarEntry;
-import java.util.jar.JarFile;
-import java.util.zip.CRC32;
 
 @Slf4j
 public class PluginResolver {
@@ -123,5 +119,4 @@ public class PluginResolver {
 
         return urls;
     }
-
 }

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

@@ -308,10 +308,6 @@ public class RegisteredPlugin {
         }
         return null;
     }
-    
-    public long crc32() {
-        return Optional.ofNullable(externalPlugin).map(ExternalPlugin::getCrc32).orElse(-1L);
-    }
 
     @Override
     public String toString() {

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

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

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

@@ -5,9 +5,11 @@ import io.kestra.core.models.executions.ExecutionKilled;
 import io.kestra.core.models.executions.LogEntry;
 import io.kestra.core.models.executions.MetricEntry;
 import io.kestra.core.models.flows.FlowInterface;
-import io.kestra.core.models.templates.Template;
+import io.kestra.core.models.flows.FlowWithSource;
 import io.kestra.core.models.triggers.Trigger;
 import io.kestra.core.runners.*;
+import io.kestra.core.models.flows.Flow;
+import io.kestra.core.models.templates.Template;
 
 public interface QueueFactoryInterface {
     String EXECUTION_NAMED = "executionQueue";
@@ -32,7 +34,7 @@ public interface QueueFactoryInterface {
 
     QueueInterface<Executor> executor();
 
-    WorkerJobQueueInterface workerJob();
+    QueueInterface<WorkerJob> workerJob();
 
     QueueInterface<WorkerTaskResult> workerTaskResult();
 

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

@@ -5,7 +5,6 @@ import io.kestra.core.models.Pauseable;
 import io.kestra.core.utils.Either;
 
 import java.io.Closeable;
-import java.util.List;
 import java.util.function.Consumer;
 
 public interface QueueInterface<T> extends Closeable, Pauseable {
@@ -19,15 +18,7 @@ public interface QueueInterface<T> extends Closeable, Pauseable {
         emitAsync(null, message);
     }
 
-    default void emitAsync(String consumerGroup, T message) throws QueueException {
-        emitAsync(consumerGroup, List.of(message));
-    }
-
-    default void emitAsync(List<T> messages) throws QueueException {
-        emitAsync(null, messages);
-    }
-
-    void emitAsync(String consumerGroup, List<T> messages) throws QueueException;
+    void emitAsync(String consumerGroup, T message) throws QueueException;
 
     default void delete(T message) throws QueueException {
         delete(null, message);

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

@@ -1,12 +0,0 @@
-package io.kestra.core.queues;
-
-import java.io.Serial;
-
-public class UnsupportedMessageException extends QueueException {
-    @Serial
-    private static final long serialVersionUID = 1L;
-
-    public UnsupportedMessageException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}

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

@@ -1,12 +0,0 @@
-package io.kestra.core.queues;
-
-import io.kestra.core.exceptions.DeserializationException;
-import io.kestra.core.runners.WorkerJob;
-import io.kestra.core.utils.Either;
-
-import java.util.function.Consumer;
-
-public interface WorkerJobQueueInterface extends QueueInterface<WorkerJob> {
-    
-    Runnable subscribe(String workerId, String workerGroup, Consumer<Either<WorkerJob, DeserializationException>> consumer);
-}

core/src/main/java/io/kestra/core/reporter/AbstractReportable.java

@@ -1,29 +0,0 @@
-package io.kestra.core.reporter;
-
-public abstract class AbstractReportable<T extends Reportable.Event> implements Reportable<T> {
-    
-    private final Type type;
-    private final ReportingSchedule schedule;
-    private final boolean isTenantSupported;
-    
-    public AbstractReportable(Type type, ReportingSchedule schedule, boolean isTenantSupported) {
-        this.type = type;
-        this.schedule = schedule;
-        this.isTenantSupported = isTenantSupported;
-    }
-    
-    @Override
-    public boolean isTenantSupported() {
-        return isTenantSupported;
-    }
-    
-    @Override
-    public Type type() {
-        return type;
-    }
-    
-    @Override
-    public ReportingSchedule schedule() {
-        return schedule;
-    }
-}

core/src/main/java/io/kestra/core/reporter/Reportable.java

@@ -1,94 +0,0 @@
-package io.kestra.core.reporter;
-
-import java.time.Duration;
-import java.time.Instant;
-import java.time.ZoneId;
-import java.time.ZonedDateTime;
-
-/**
- * Interface for reporting server event for a specific type.
- *
- * @param <T>
- */
-public interface Reportable<T extends Reportable.Event> {
-    
-    /**
-     * Gets the type of the event to report.
-     */
-    Type type();
-    
-    /**
-     * Gets the reporting schedule.
-     */
-    ReportingSchedule schedule();
-    
-    /**
-     * Generates a report for the given timestamp.
-     *
-     * @param now the time when the report is triggered.
-     * @return an Optional containing the report data if available.
-     */
-    T report(Instant now, TimeInterval interval);
-    
-    default T report(Instant now) {
-        ZonedDateTime to = now.atZone(ZoneId.systemDefault());
-        ZonedDateTime from = to.minus(Duration.ofDays(1));
-        return report(now, new TimeInterval(from, to));
-    }
-    
-    /**
-     * Checks whether this reportable is enabled for scheduled reporting.
-     */
-    boolean isEnabled();
-    
-    /**
-     * Generates a report for the given timestamp and tenant.
-     *
-     * @param now    the time when the report is triggered.
-     * @param tenant the tenant for which the report is triggered.
-     * @return the event to report.
-     */
-    default T report(Instant now, TimeInterval interval, String tenant) {
-        throw new UnsupportedOperationException();
-    }
-    
-    default T report(Instant now, String tenant) {
-        ZonedDateTime to = now.atZone(ZoneId.systemDefault());
-        ZonedDateTime from = to.minus(Duration.ofDays(1));
-        return report(now, new TimeInterval(from, to), tenant);
-    }
-    
-    /**
-     * Checks whether this {@link Reportable} can accept a tenant.
-     * 
-     * @return {@code true} a {@link #report(Instant, TimeInterval, String)} can called, Otherwise {@code false}.
-     */
-    default boolean isTenantSupported() {
-        return false;
-    }
-    
-    record TimeInterval(ZonedDateTime from, ZonedDateTime to){
-        public static TimeInterval of(ZonedDateTime from, ZonedDateTime to) {
-            return new TimeInterval(from, to);
-        }
-    }
-    
-    /**
-     * Marker interface indicating that the returned event 
-     * must be a structured, domain-specific object 
-     * (not a primitive wrapper, String, collection, or other basic type).
-     */
-    interface Event {
-        
-    }
-    
-    /**
-     * Defines the schedule for a report.
-     */
-    interface ReportingSchedule {
-        /**
-         * Determines whether a report should run at the given instant.
-         */
-        boolean shouldRun(Instant now);
-    }
-}

core/src/main/java/io/kestra/core/reporter/ReportableRegistry.java

@@ -1,40 +0,0 @@
-package io.kestra.core.reporter;
-
-import jakarta.inject.Inject;
-import jakarta.inject.Singleton;
-import lombok.extern.slf4j.Slf4j;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.concurrent.ConcurrentHashMap;
-
-@Singleton
-@Slf4j
-public class ReportableRegistry {
-    
-    private final Map<Type, Reportable<?>> reportables = new ConcurrentHashMap<>();
-    
-    /**
-     * Creates a new {@link ReportableRegistry} instance.
-     *
-     * @param reportables The {@link Reportable reportables}
-     */
-    @Inject
-    public ReportableRegistry(final List<Reportable<?>> reportables) {
-        reportables.forEach(reportable -> this.reportables.put(reportable.type(), reportable));
-    }
-    
-    public void register(final Reportable<?> reportable) {
-        Objects.requireNonNull(reportable, "reportable must not be null");
-        if (reportables.containsKey(reportable.type())) {
-            log.warn("Event already registered for type '{}'", reportable.type());
-        } else {
-            reportables.put(reportable.type(), reportable);
-        }
-    }
-    
-    public List<Reportable<?>> getAll() {
-        return List.copyOf(reportables.values());
-    }
-}

core/src/main/java/io/kestra/core/reporter/ReportableScheduler.java

@@ -1,43 +0,0 @@
-package io.kestra.core.reporter;
-
-import io.micronaut.context.annotation.Requires;
-import io.micronaut.scheduling.annotation.Scheduled;
-import jakarta.inject.Inject;
-import jakarta.inject.Singleton;
-import lombok.extern.slf4j.Slf4j;
-
-import java.time.Clock;
-import java.time.Instant;
-
-@Singleton
-@Requires(property = "kestra.anonymous-usage-report.enabled", value = "true")
-@Requires(property = "kestra.server-type")
-@Slf4j
-public class ReportableScheduler {
-    
-    private final ReportableRegistry registry;
-    private final ServerEventSender sender;
-    private final Clock clock;
-    
-    @Inject
-    public ReportableScheduler(ReportableRegistry registry, ServerEventSender sender) {
-        this.registry = registry;
-        this.sender = sender;
-        this.clock = Clock.systemDefaultZone();
-    }
-    
-    @Scheduled(fixedDelay = "5m", initialDelay = "${kestra.anonymous-usage-report.initial-delay}")
-    public void tick() {
-        Instant now = clock.instant();
-        for (Reportable<?> r : registry.getAll()) {
-            if (r.isEnabled() && r.schedule().shouldRun(now)) {
-                try {
-                    Object value = r.report(now);
-                    if (value != null) sender.send(now, r.type(), value);
-                } catch (Exception e) {
-                    log.debug("Failed to send report for event-type '{}'", r.type(), e);
-                }
-            }
-        }
-    }
-}

core/src/main/java/io/kestra/core/reporter/Schedules.java

@@ -1,57 +0,0 @@
-package io.kestra.core.reporter;
-
-import io.kestra.core.reporter.Reportable.ReportingSchedule;
-
-import java.time.Duration;
-import java.time.Instant;
-
-/**
- * Utility class providing common implementations of {@link Reportable.ReportingSchedule}.
- */
-public class Schedules {
-    
-    /**
-     * Creates a reporting schedule that triggers after the specified period has elapsed
-     * since the last execution.
-     *
-     * @param period the duration between successive runs; must be positive
-     * @return a {@link Reportable.ReportingSchedule} that runs at the given interval
-     * @throws IllegalArgumentException if {@code period} is zero or negative
-     */
-    public static ReportingSchedule every(final Duration period) {
-        if (period.isZero() || period.isNegative()) {
-            throw new IllegalArgumentException("Period must be positive");
-        }
-        
-        return new ReportingSchedule() {
-            private Instant lastRun = Instant.EPOCH;
-            
-            @Override
-            public boolean shouldRun(Instant now) {
-                if (Duration.between(lastRun, now).compareTo(period) >= 0) {
-                    lastRun = now;
-                    return true;
-                }
-                return false;
-            }
-        };
-    }
-    
-    /**
-     * Creates a reporting schedule that triggers once every hour.
-     *
-     * @return a schedule running every 1 hour
-     */
-    public static ReportingSchedule hourly() {
-        return every(Duration.ofHours(1));
-    }
-    
-    /**
-     * Creates a reporting schedule that triggers once every day.
-     *
-     * @return a schedule running every 24 hours
-     */
-    public static ReportingSchedule daily() {
-        return every(Duration.ofDays(1));
-    }
-}

core/src/main/java/io/kestra/core/reporter/ServerEvent.java

@@ -1,31 +0,0 @@
-package io.kestra.core.reporter;
-
-import com.fasterxml.jackson.annotation.JsonUnwrapped;
-import io.kestra.core.models.ServerType;
-import lombok.Builder;
-
-import java.time.ZoneId;
-import java.time.ZonedDateTime;
-
-/**
- * Represents a Kestra Server Event.
- */
-@Builder(toBuilder = true)
-public record ServerEvent(
-    String instanceUuid,
-    String sessionUuid,
-    ServerType serverType,
-    String serverVersion,
-    ZoneId zoneId,
-    Object payload,
-    String uuid,
-    ZonedDateTime reportedAt
-) {
-    
-    @JsonUnwrapped
-    public Object payload() {
-        return payload;
-    }
-    
-}
-

core/src/main/java/io/kestra/core/reporter/ServerEventSender.java

@@ -1,91 +0,0 @@
-package io.kestra.core.reporter;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import io.kestra.core.contexts.KestraContext;
-import io.kestra.core.models.ServerType;
-import io.kestra.core.models.collectors.Result;
-import io.kestra.core.serializers.JacksonMapper;
-import io.kestra.core.services.InstanceService;
-import io.kestra.core.utils.IdUtils;
-import io.kestra.core.utils.VersionProvider;
-import io.micronaut.context.annotation.Value;
-import io.micronaut.core.type.Argument;
-import io.micronaut.http.HttpRequest;
-import io.micronaut.http.MutableHttpRequest;
-import io.micronaut.http.client.annotation.Client;
-import io.micronaut.http.client.exceptions.HttpClientResponseException;
-import io.micronaut.http.hateoas.JsonError;
-import io.micronaut.reactor.http.client.ReactorHttpClient;
-import jakarta.inject.Inject;
-import jakarta.inject.Singleton;
-import lombok.extern.slf4j.Slf4j;
-
-import java.net.URI;
-import java.time.Instant;
-import java.time.ZoneId;
-import java.util.UUID;
-
-@Singleton
-@Slf4j
-public class ServerEventSender {
-    
-    private static final String SESSION_UUID = IdUtils.create();
-    private static final ObjectMapper OBJECT_MAPPER = JacksonMapper.ofJson();
-    
-    @Inject
-    @Client
-    private ReactorHttpClient client;
-    
-    @Inject
-    private VersionProvider versionProvider;
-    
-    @Inject
-    private InstanceService instanceService;
-    
-    private final ServerType serverType;
-    
-    @Value("${kestra.anonymous-usage-report.uri}")
-    protected URI url;
-    
-    public ServerEventSender( ) {
-        this.serverType = KestraContext.getContext().getServerType();
-    }
-    
-    public void send(final Instant now, final Type type, Object event) {
-        ServerEvent serverEvent = ServerEvent
-            .builder()
-            .uuid(UUID.randomUUID().toString())
-            .sessionUuid(SESSION_UUID)
-            .instanceUuid(instanceService.fetch())
-            .serverType(serverType)
-            .serverVersion(versionProvider.getVersion())
-            .reportedAt(now.atZone(ZoneId.systemDefault()))
-            .payload(event)
-            .zoneId(ZoneId.systemDefault())
-            .build();
-        try {
-            MutableHttpRequest<ServerEvent> request = this.request(serverEvent, type);
-            
-            if (log.isTraceEnabled()) {
-                log.trace("Report anonymous usage: '{}'", OBJECT_MAPPER.writeValueAsString(serverEvent));
-            }
-            
-            this.handleResponse(client.toBlocking().retrieve(request, Argument.of(Result.class), Argument.of(JsonError.class)));
-        } catch (HttpClientResponseException t) {
-            log.trace("Unable to report anonymous usage with body '{}'", t.getResponse().getBody(String.class), t);
-        } catch (Exception t) {
-            log.trace("Unable to handle anonymous usage", t);
-        }
-    }
-    
-    private void handleResponse (Result result){
-        
-    }
-    
-    protected MutableHttpRequest<ServerEvent> request(ServerEvent event, Type type) throws Exception {
-        URI baseUri = URI.create(this.url.toString().endsWith("/") ? this.url.toString() : this.url + "/");
-        URI resolvedUri = baseUri.resolve(type.name().toLowerCase());
-        return HttpRequest.POST(resolvedUri, event)
-            .header("User-Agent", "Kestra/" + versionProvider.getVersion());
-    }
-}

core/src/main/java/io/kestra/core/reporter/Type.java

@@ -1,9 +0,0 @@
-package io.kestra.core.reporter;
-
-/**
- * A reportable event type.
- */
-public interface Type {
-    
-    String name();
-}

core/src/main/java/io/kestra/core/reporter/Types.java

@@ -1,12 +0,0 @@
-package io.kestra.core.reporter;
-
-/**
- * All supported reportable event type.
- */
-public enum Types implements Type {
-    USAGE,
-    SYSTEM_INFORMATION,
-    PLUGIN_METRICS,
-    SERVICE_USAGE,
-    PLUGIN_USAGE;
-}

core/src/main/java/io/kestra/core/reporter/model/Count.java

@@ -1,6 +0,0 @@
-package io.kestra.core.reporter.model;
-
-public record Count(
-    long count
-) {
-}

core/src/main/java/io/kestra/core/reporter/reports/FeatureUsageReport.java

@@ -1,80 +0,0 @@
-package io.kestra.core.reporter.reports;
-
-import io.kestra.core.contexts.KestraContext;
-import io.kestra.core.models.ServerType;
-import io.kestra.core.models.collectors.ExecutionUsage;
-import io.kestra.core.models.collectors.FlowUsage;
-import io.kestra.core.reporter.AbstractReportable;
-import io.kestra.core.reporter.Schedules;
-import io.kestra.core.reporter.Types;
-import io.kestra.core.reporter.model.Count;
-import io.kestra.core.repositories.DashboardRepositoryInterface;
-import io.kestra.core.repositories.ExecutionRepositoryInterface;
-import io.kestra.core.repositories.FlowRepositoryInterface;
-import io.micronaut.core.annotation.Introspected;
-import jakarta.inject.Inject;
-import jakarta.inject.Singleton;
-import lombok.Getter;
-import lombok.experimental.SuperBuilder;
-import lombok.extern.jackson.Jacksonized;
-
-import java.time.Instant;
-import java.util.Objects;
-
-@Singleton
-public class FeatureUsageReport extends AbstractReportable<FeatureUsageReport.UsageEvent> {
-    
-    private final FlowRepositoryInterface flowRepository;
-    private final ExecutionRepositoryInterface executionRepository;
-    private final DashboardRepositoryInterface dashboardRepository;
-    private final boolean enabled;
-    
-    @Inject
-    public FeatureUsageReport(FlowRepositoryInterface flowRepository,
-                              ExecutionRepositoryInterface executionRepository,
-                              DashboardRepositoryInterface dashboardRepository) {
-        super(Types.USAGE, Schedules.hourly(), true);
-        this.flowRepository = flowRepository;
-        this.executionRepository = executionRepository;
-        this.dashboardRepository = dashboardRepository;
-        
-        ServerType serverType = KestraContext.getContext().getServerType();
-        this.enabled = ServerType.EXECUTOR.equals(serverType) || ServerType.STANDALONE.equals(serverType);
-    }
-    
-    @Override
-    public UsageEvent report(final Instant now, TimeInterval interval) {
-        return UsageEvent
-            .builder()
-            .flows(FlowUsage.of(flowRepository))
-            .executions(ExecutionUsage.of(executionRepository, interval.from(), interval.to()))
-            .dashboards(new Count(dashboardRepository.count()))
-            .build();
-    }
-    
-    @Override
-    public boolean isEnabled() {
-        return enabled;
-    }
-    
-    @Override
-    public UsageEvent report(Instant now, TimeInterval interval, String tenant) {
-        Objects.requireNonNull(tenant, "tenant is null");
-        Objects.requireNonNull(interval, "interval is null");
-        return UsageEvent
-            .builder()
-            .flows(FlowUsage.of(tenant, flowRepository))
-            .executions(ExecutionUsage.of(tenant, executionRepository, interval.from(), interval.to()))
-            .build();
-    }
-    
-    @SuperBuilder(toBuilder = true)
-    @Getter
-    @Jacksonized
-    @Introspected
-    public static class UsageEvent implements Event {
-        private ExecutionUsage executions;
-        private FlowUsage flows;
-        private Count dashboards;
-    }
-}

core/src/main/java/io/kestra/core/reporter/reports/PluginMetricReport.java

@@ -1,105 +0,0 @@
-package io.kestra.core.reporter.reports;
-
-import io.kestra.core.contexts.KestraContext;
-import io.kestra.core.metrics.MetricRegistry;
-import io.kestra.core.models.ServerType;
-import io.kestra.core.models.collectors.PluginMetric;
-import io.kestra.core.plugins.PluginRegistry;
-import io.kestra.core.reporter.AbstractReportable;
-import io.kestra.core.reporter.Schedules;
-import io.kestra.core.reporter.Types;
-import io.kestra.core.utils.ListUtils;
-import io.micrometer.core.instrument.Timer;
-import io.micronaut.core.annotation.Introspected;
-import jakarta.inject.Inject;
-import jakarta.inject.Singleton;
-import lombok.Builder;
-
-import java.time.Instant;
-import java.util.List;
-import java.util.Optional;
-import java.util.concurrent.TimeUnit;
-
-@Singleton
-public class PluginMetricReport extends AbstractReportable<PluginMetricReport.PluginMetricEvent> {
-    
-    private final PluginRegistry pluginRegistry;
-    private final MetricRegistry metricRegistry;
-    private final boolean enabled;
-    
-    @Inject
-    public PluginMetricReport(PluginRegistry pluginRegistry,
-                              MetricRegistry metricRegistry) {
-        super(Types.PLUGIN_METRICS, Schedules.daily(), false);
-        this.metricRegistry = metricRegistry;
-        this.pluginRegistry = pluginRegistry;
-        
-        ServerType serverType = KestraContext.getContext().getServerType();
-        this.enabled = ServerType.SCHEDULER.equals(serverType) || ServerType.WORKER.equals(serverType) || ServerType.STANDALONE.equals(serverType);
-    }
-    
-    @Override
-    public PluginMetricEvent report(final Instant now, final TimeInterval period) {
-        return PluginMetricEvent
-            .builder()
-            .pluginMetrics(pluginMetrics())
-            .build();
-    }
-    
-    @Override
-    public boolean isEnabled() {
-        return enabled;
-    }
-    
-    @Builder
-    @Introspected
-    public record PluginMetricEvent (
-        List<PluginMetric> pluginMetrics
-    ) implements Event {
-    }
-    
-    private List<PluginMetric> pluginMetrics() {
-        List<PluginMetric> taskMetrics = pluginRegistry.plugins().stream()
-            .flatMap(registeredPlugin -> registeredPlugin.getTasks().stream())
-            .map(Class::getName)
-            .map(this::taskMetric)
-            .flatMap(Optional::stream)
-            .toList();
-        
-        List<PluginMetric> triggerMetrics = pluginRegistry.plugins().stream()
-            .flatMap(registeredPlugin -> registeredPlugin.getTriggers().stream())
-            .map(Class::getName)
-            .map(this::triggerMetric)
-            .flatMap(Optional::stream)
-            .toList();
-        
-        return ListUtils.concat(taskMetrics, triggerMetrics);
-    }
-    
-    private Optional<PluginMetric> taskMetric(String type) {
-        Timer duration = metricRegistry.find(MetricRegistry.METRIC_WORKER_ENDED_DURATION).tag(MetricRegistry.TAG_TASK_TYPE, type).timer();
-        return fromTimer(type, duration);
-    }
-    
-    private Optional<PluginMetric> triggerMetric(String type) {
-        Timer duration = metricRegistry.find(MetricRegistry.METRIC_WORKER_TRIGGER_DURATION).tag(MetricRegistry.TAG_TRIGGER_TYPE, type).timer();
-        
-        if (duration == null) {
-            // this may be because this is a trigger executed by the scheduler, we search there instead
-            duration = metricRegistry.find(MetricRegistry.METRIC_SCHEDULER_TRIGGER_EVALUATION_DURATION).tag(MetricRegistry.TAG_TRIGGER_TYPE, type).timer();
-        }
-        return fromTimer(type, duration);
-    }
-    
-    private Optional<PluginMetric> fromTimer(String type, Timer timer) {
-        if (timer == null || timer.count() == 0) {
-            return Optional.empty();
-        }
-        
-        double count = timer.count();
-        double totalTime = timer.totalTime(TimeUnit.MILLISECONDS);
-        double meanTime = timer.mean(TimeUnit.MILLISECONDS);
-        
-        return Optional.of(new PluginMetric(type, count, totalTime, meanTime));
-    }
-}

core/src/main/java/io/kestra/core/reporter/reports/PluginUsageReport.java

@@ -1,51 +0,0 @@
-package io.kestra.core.reporter.reports;
-
-import io.kestra.core.contexts.KestraContext;
-import io.kestra.core.models.ServerType;
-import io.kestra.core.models.collectors.PluginUsage;
-import io.kestra.core.plugins.PluginRegistry;
-import io.kestra.core.reporter.AbstractReportable;
-import io.kestra.core.reporter.Schedules;
-import io.kestra.core.reporter.Types;
-import io.micronaut.core.annotation.Introspected;
-import jakarta.inject.Inject;
-import jakarta.inject.Singleton;
-import lombok.Builder;
-
-import java.time.Instant;
-import java.util.List;
-
-@Singleton
-public class PluginUsageReport extends AbstractReportable<PluginUsageReport.PluginUsageEvent> {
-    
-    private final PluginRegistry pluginRegistry;
-    private final boolean enabled;
-    @Inject
-    public PluginUsageReport(PluginRegistry pluginRegistry) {
-        super(Types.PLUGIN_USAGE, Schedules.daily(), false);
-        this.pluginRegistry = pluginRegistry;
-        
-        ServerType serverType = KestraContext.getContext().getServerType();
-        this.enabled = ServerType.EXECUTOR.equals(serverType) || ServerType.STANDALONE.equals(serverType);
-    }
-    
-    @Override
-    public PluginUsageEvent report(final Instant now, final TimeInterval period) {
-        return PluginUsageEvent
-            .builder()
-            .plugins(PluginUsage.of(pluginRegistry))
-            .build();
-    }
-    
-    @Override
-    public boolean isEnabled() {
-        return enabled;
-    }
-    
-    @Builder
-    @Introspected
-    public record PluginUsageEvent(
-        List<PluginUsage> plugins
-    ) implements Event {
-    }
-}

core/src/main/java/io/kestra/core/reporter/reports/ServiceUsageReport.java

@@ -1,53 +0,0 @@
-package io.kestra.core.reporter.reports;
-
-import io.kestra.core.contexts.KestraContext;
-import io.kestra.core.models.ServerType;
-import io.kestra.core.models.collectors.ServiceUsage;
-import io.kestra.core.reporter.AbstractReportable;
-import io.kestra.core.reporter.Schedules;
-import io.kestra.core.reporter.Types;
-import io.kestra.core.repositories.ServiceInstanceRepositoryInterface;
-import io.micronaut.core.annotation.Introspected;
-import jakarta.inject.Inject;
-import jakarta.inject.Singleton;
-import lombok.Builder;
-
-import java.time.Duration;
-import java.time.Instant;
-
-@Singleton
-public class ServiceUsageReport extends AbstractReportable<ServiceUsageReport.ServiceUsageEvent> {
-    
-    private final ServiceInstanceRepositoryInterface serviceInstanceRepository;
-    private final boolean isEnabled;
-    
-    @Inject
-    public ServiceUsageReport(ServiceInstanceRepositoryInterface serviceInstanceRepository) {
-        super(Types.SERVICE_USAGE, Schedules.daily(), false);
-        this.serviceInstanceRepository = serviceInstanceRepository;
-        
-        ServerType serverType = KestraContext.getContext().getServerType();
-        this.isEnabled = ServerType.STANDALONE.equals(serverType) || ServerType.EXECUTOR.equals(serverType);
-    }
-    
-    @Override
-    public ServiceUsageEvent report(final Instant now, final TimeInterval period) {
-        
-        return ServiceUsageEvent
-            .builder()
-            .services(ServiceUsage.of(period.from().toInstant(), period.to().toInstant(), serviceInstanceRepository, Duration.ofMinutes(5)))
-            .build();
-    }
-    
-    @Override
-    public boolean isEnabled() {
-        return isEnabled;
-    }
-    
-    @Builder
-    @Introspected
-    public record ServiceUsageEvent(
-        ServiceUsage services
-    ) implements Event {
-    }
-}

core/src/main/java/io/kestra/core/reporter/reports/SystemInformationReport.java

@@ -1,63 +0,0 @@
-package io.kestra.core.reporter.reports;
-
-import io.kestra.core.models.collectors.ConfigurationUsage;
-import io.kestra.core.models.collectors.HostUsage;
-import io.kestra.core.reporter.AbstractReportable;
-import io.kestra.core.reporter.Schedules;
-import io.kestra.core.reporter.Types;
-import io.micronaut.context.ApplicationContext;
-import io.micronaut.context.env.Environment;
-import io.micronaut.core.annotation.Introspected;
-import jakarta.inject.Inject;
-import jakarta.inject.Singleton;
-import lombok.Builder;
-
-import java.lang.management.ManagementFactory;
-import java.time.Instant;
-import java.util.Set;
-
-@Singleton
-public class SystemInformationReport extends AbstractReportable<SystemInformationReport.SystemInformationEvent> {
-    
-    private final Environment environment;
-    private final ApplicationContext applicationContext;
-    private final String kestraUrl;
-    private final Instant startTime;
-    
-    @Inject
-    public SystemInformationReport(ApplicationContext applicationContext) {
-        super(Types.SYSTEM_INFORMATION, Schedules.daily(), false);
-        this.environment = applicationContext.getEnvironment();
-        this.applicationContext = applicationContext;
-        this.kestraUrl = applicationContext.getProperty("kestra.url", String.class).orElse(null);
-        this.startTime = Instant.ofEpochMilli(ManagementFactory.getRuntimeMXBean().getStartTime());
-    }
-    
-    @Override
-    public SystemInformationEvent report(final Instant now, final TimeInterval timeInterval) {
-        return SystemInformationEvent
-            .builder()
-            .environments(environment.getActiveNames())
-            .configurations(ConfigurationUsage.of(applicationContext))
-            .startTime(startTime)
-            .host(HostUsage.of())
-            .uri(kestraUrl)
-            .build();
-    }
-    
-    @Override
-    public boolean isEnabled() {
-        return true;
-    }
-    
-    @Builder
-    @Introspected
-    public record SystemInformationEvent(
-        Set<String> environments,
-        HostUsage host,
-        ConfigurationUsage configurations,
-        Instant startTime,
-        String uri
-    ) implements Event {
-    }
-}

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

@@ -16,14 +16,6 @@ import java.util.Map;
 import java.util.Optional;
 
 public interface DashboardRepositoryInterface {
-    
-    /**
-     * Gets the total number of Dashboards.
-     *
-     * @return the total number.
-     */
-    long count();
-    
     Boolean isEnabled();
 
     Optional<Dashboard> get(String tenantId, String id);

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

@@ -25,6 +25,8 @@ import java.util.Optional;
 import java.util.function.Function;
 
 public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Execution>, QueryBuilderInterface<Executions.Fields> {
+    Boolean isTaskRunEnabled();
+
     default Optional<Execution> findById(String tenantId, String id) {
         return findById(tenantId, id, false);
     }
@@ -94,6 +96,12 @@ 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);
@@ -104,7 +112,8 @@ public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Ex
         @Nullable String flowId,
         @Nullable ZonedDateTime startDate,
         @Nullable ZonedDateTime endDate,
-        @Nullable DateUtils.GroupType groupBy
+        @Nullable DateUtils.GroupType groupBy,
+        boolean isTaskRun
     );
 
     List<DailyExecutionStatistics> dailyStatistics(
@@ -116,7 +125,8 @@ public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Ex
         @Nullable ZonedDateTime startDate,
         @Nullable ZonedDateTime endDate,
         @Nullable DateUtils.GroupType groupBy,
-        List<State.Type> state
+        List<State.Type> state,
+        boolean isTaskRun
     );
 
     @Getter

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

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