chore(ci): properly checkout pull request HEAD instead of merge commit in gh actions.

See https://github.com/actions/checkout#checkout-pull-request-head-commit-instead-of-merge-commit. Signed-off-by: Federico Di Pierro <nierro92@gmail.com>
fix(cmake): properly fetch dev version by appending latest Falco tag, delta between master and tag, and hash.
2026-03-20 11:42:06 +00:00 · 2022-12-05 15:59:30 +01:00 · 2022-12-05 15:55:17 +01:00
201 changed files with 9021 additions and 8046 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -3,61 +3,56 @@ jobs:
  "build-arm64":
    machine:
      enabled: true
-      image: ubuntu-2204:2022.10.2
-    resource_class: arm.large
+      image: ubuntu-2004:202101-01
+    resource_class: arm.medium
    steps:
-
-      # Install dependencies to build the modern BPF probe skeleton.
-      - run:
-          name: Install deps ⛓️
-          command: |
-            sudo apt update
-            sudo apt install -y --no-install-recommends ca-certificates cmake build-essential clang-14 git pkg-config autoconf automake libelf-dev
-            sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-14 90
-            sudo update-alternatives --install /usr/bin/llvm-strip llvm-strip /usr/bin/llvm-strip-14 90
-            git clone https://github.com/libbpf/bpftool.git --branch v7.0.0 --single-branch
-            cd bpftool
-            git submodule update --init
-            cd src && sudo make install
-
-      # Path to the source code
      - checkout:
          path: /tmp/source-arm64/falco
-
-      # Build the skeleton
      - run:
-          name: Build modern BPF skeleton 🐝
+          name: Prepare project
          command: |
-            mkdir -p /tmp/source-arm64/falco/skeleton-build
-            cd /tmp/source-arm64/falco/skeleton-build && cmake -DUSE_BUNDLED_DEPS=ON -DBUILD_FALCO_MODERN_BPF=ON -DCREATE_TEST_TARGETS=Off ../
-            make ProbeSkeleton
-
-      # Build the Falco packages (tar, deb, rpm) inside the centos7 builder.
-      # This dockerfile returns as output:
-      # - the build directory. (under /tmp/${DEST_BUILD_DIR})
-      # - the 3 packages: tar, deb, rpm. (under /tmp/packages)
+            mkdir -p /tmp/build-arm64 && mkdir -p /tmp/build-arm64/release && \
+            docker run -e BUILD_TYPE="release" -it -v /tmp/source-arm64:/source -v /tmp/build-arm64:/build \
+              falcosecurity/falco-builder:latest \
+              cmake
      - run:
-          name: Build Falco packages 🏗️
+          name: Build
          command: |
-            FALCO_VERSION=$(cat /tmp/source-arm64/falco/skeleton-build/userspace/falco/config_falco.h | grep 'FALCO_VERSION ' | cut -d' ' -f3 | sed -e 's/^"//' -e 's/"$//')
-            DOCKER_BUILDKIT=1 docker build -f /tmp/source-arm64/falco/docker/builder/modern-falco-builder.Dockerfile --output type=local,dest=/tmp --build-arg CMAKE_OPTIONS="-DCMAKE_BUILD_TYPE=Release -DUSE_BUNDLED_DEPS=On -DFALCO_ETC_DIR=/etc/falco -DBUILD_FALCO_MODERN_BPF=ON -DMODERN_BPF_SKEL_DIR=/source/skeleton-build/skel_dir -DBUILD_DRIVER=Off -DBUILD_BPF=Off -DFALCO_VERSION=${FALCO_VERSION}" --build-arg DEST_BUILD_DIR=/build-arm64/release /tmp/source-arm64/falco
-
+            docker run -e BUILD_TYPE="release" -it -v /tmp/source-arm64:/source -v /tmp/build-arm64:/build \
+              falcosecurity/falco-builder:latest \
+              all
+      - run:
+          name: Run unit tests
+          command: |
+            docker run -e BUILD_TYPE="release" -it -v /tmp/source-arm64:/source -v /tmp/build-arm64:/build \
+              falcosecurity/falco-builder:latest \
+              tests
+      - run:
+          name: Build packages
+          command: |
+            docker run -e BUILD_TYPE="release" -it -v /tmp/source-arm64:/source -v /tmp/build-arm64:/build \
+              falcosecurity/falco-builder:latest \
+              package
+      - run:
+          name: Prepare Artifacts
+          command: |
+            mkdir -p /tmp/packages
+            cp /tmp/build-arm64/release/*.deb /tmp/packages
+            cp /tmp/build-arm64/release/*.tar.gz /tmp/packages
+            cp /tmp/build-arm64/release/*.rpm /tmp/packages
      - store_artifacts:
          path: /tmp/packages
          destination: /packages
-
      - persist_to_workspace:
          root: /tmp
          paths:
            - build-arm64/release
            - source-arm64
-
  # Build a statically linked Falco release binary using musl
  # This build is 100% static, there are no host dependencies
  "build-musl":
    docker:
-      - image: alpine:3.17
-    resource_class: large
+      - image: alpine:3.12
    steps:
      - checkout:
          path: /source-static/falco
@@ -66,23 +61,28 @@ jobs:
          command: apk update
      - run:
          name: Install build dependencies
-          command: apk add g++ gcc cmake make git bash perl linux-headers autoconf automake m4 libtool elfutils-dev libelf-static patch binutils bpftool clang
+          command: apk add g++ gcc cmake make git bash perl linux-headers autoconf automake m4 libtool elfutils-dev libelf-static patch binutils
      - run:
          name: Prepare project
          command: |
            mkdir -p /build-static/release
            cd /build-static/release
-            cmake -DCPACK_GENERATOR=TGZ -DBUILD_BPF=Off -DBUILD_DRIVER=Off -DCMAKE_BUILD_TYPE=Release -DUSE_BUNDLED_DEPS=On -DUSE_BUNDLED_LIBELF=Off -DBUILD_LIBSCAP_MODERN_BPF=ON -DMUSL_OPTIMIZED_BUILD=On -DFALCO_ETC_DIR=/etc/falco /source-static/falco
+            cmake -DCPACK_GENERATOR=TGZ -DBUILD_BPF=Off -DBUILD_DRIVER=Off -DCMAKE_BUILD_TYPE=Release -DUSE_BUNDLED_DEPS=On -DUSE_BUNDLED_LIBELF=Off -DMUSL_OPTIMIZED_BUILD=On -DFALCO_ETC_DIR=/etc/falco /source-static/falco
      - run:
          name: Build
          command: |
            cd /build-static/release
-            make -j6 all
+            make -j4 all
      - run:
          name: Package
          command: |
            cd /build-static/release
-            make -j6 package
+            make -j4 package
+      - run:
+          name: Run unit tests
+          command: |
+            cd /build-static/release
+            make tests
      - run:
          name: Prepare artifacts
          command: |
@@ -96,59 +96,43 @@ jobs:
          paths:
            - build-static/release
            - source-static
-
+  # Build using our own builder base image using centos 7
  # This build is static, dependencies are bundled in the Falco binary
  "build-centos7":
-    machine:
-      enabled: true
-      image: ubuntu-2204:2022.10.2
-    resource_class: large
+    docker:
+      - image: falcosecurity/falco-builder:latest
+        environment:
+          BUILD_TYPE: "release"
    steps:
-
-      # Install dependencies to build the modern BPF probe skeleton.
-      - run:
-          name: Install deps ⛓️
-          command: |
-            sudo apt update
-            sudo apt install -y --no-install-recommends ca-certificates cmake build-essential clang-14 git pkg-config autoconf automake libelf-dev
-            sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-14 90
-            sudo update-alternatives --install /usr/bin/llvm-strip llvm-strip /usr/bin/llvm-strip-14 90
-            git clone https://github.com/libbpf/bpftool.git --branch v7.0.0 --single-branch
-            cd bpftool
-            git submodule update --init
-            cd src && sudo make install
-
-      # Path for the source code
      - checkout:
-          path: /tmp/source/falco
-
+          path: /source/falco
      - run:
-          name: Build modern BPF skeleton 🐝
-          command: |
-            mkdir -p /tmp/source/falco/skeleton-build
-            cd /tmp/source/falco/skeleton-build && cmake -DUSE_BUNDLED_DEPS=ON -DBUILD_FALCO_MODERN_BPF=ON -DCREATE_TEST_TARGETS=Off ../
-            make ProbeSkeleton
-
-      # Build the Falco packages (tar, deb, rpm) inside the centos7 builder.
-      # This dockerfile returns as output:
-      # - the build directory. (under /tmp/${DEST_BUILD_DIR})
-      # - the 3 packages: tar, deb, rpm. (under /tmp/packages)
+          name: Prepare project
+          command: /usr/bin/entrypoint cmake
      - run:
-          name: Build Falco packages 🏗️
-          command: |
-            FALCO_VERSION=$(cat /tmp/source/falco/skeleton-build/userspace/falco/config_falco.h | grep 'FALCO_VERSION ' | cut -d' ' -f3 | sed -e 's/^"//' -e 's/"$//')
-            DOCKER_BUILDKIT=1 docker build -f /tmp/source/falco/docker/builder/modern-falco-builder.Dockerfile --output type=local,dest=/tmp --build-arg CMAKE_OPTIONS="-DCMAKE_BUILD_TYPE=Release -DUSE_BUNDLED_DEPS=On -DFALCO_ETC_DIR=/etc/falco -DBUILD_FALCO_MODERN_BPF=ON -DMODERN_BPF_SKEL_DIR=/source/skeleton-build/skel_dir -DBUILD_DRIVER=Off -DBUILD_BPF=Off -DFALCO_VERSION=${FALCO_VERSION}" --build-arg DEST_BUILD_DIR=/build/release /tmp/source/falco
-
-      - store_artifacts:
-          path: /tmp/packages
-          destination: /packages
-
+          name: Build
+          command: /usr/bin/entrypoint all
+      - run:
+          name: Run unit tests
+          command: /usr/bin/entrypoint tests
+      - run:
+          name: Build packages
+          command: /usr/bin/entrypoint package
      - persist_to_workspace:
-          root: /tmp
+          root: /
          paths:
            - build/release
            - source
-
+      - run:
+          name: Prepare artifacts
+          command: |
+            mkdir -p /tmp/packages
+            cp /build/release/*.deb /tmp/packages
+            cp /build/release/*.tar.gz /tmp/packages
+            cp /build/release/*.rpm /tmp/packages
+      - store_artifacts:
+          path: /tmp/packages
+          destination: /packages
  # Execute integration tests based on the build results coming from the "build-centos7" job
  "tests-integration":
    docker:
@@ -210,11 +194,37 @@ jobs:
      - run:
          name: Execute driver-loader integration tests
          command: /tmp/ws/source/falco/test/driver-loader/run_test.sh /tmp/ws/build/release/
-
+  # Code quality
+  "quality-static-analysis":
+    docker:
+      - image: falcosecurity/falco-builder:latest
+        environment:
+          BUILD_TYPE: "release"
+    steps:
+      - run:
+          name: Install cppcheck
+          command: |
+            yum update -y
+            yum install epel-release -y
+            yum install cppcheck cppcheck-htmlreport -y
+      - checkout:
+          path: /source/falco
+      - run:
+          name: Prepare project
+          command: /usr/bin/entrypoint cmake
+      - run:
+          name: cppcheck
+          command: /usr/bin/entrypoint cppcheck
+      - run:
+          name: cppcheck html report
+          command: /usr/bin/entrypoint cppcheck_htmlreport
+      - store_artifacts:
+          path: /build/release/static-analysis-reports
+          destination: /static-analysis-reports
  # Sign rpm packages
  "rpm-sign":
    docker:
-      - image: docker.io/centos:7
+      - image: falcosecurity/falco-builder:latest
    steps:
      - attach_workspace:
          at: /
@@ -222,7 +232,7 @@ jobs:
          name: Install rpmsign
          command: |
            yum update -y
-            yum install rpm-sign expect which -y
+            yum install rpm-sign -y
      - run:
          name: Prepare
          command: |
@@ -255,7 +265,6 @@ jobs:
          paths:
            - build/release/*.rpm
            - build-arm64/release/*.rpm
-
  # Publish the dev packages
  "publish-packages-dev":
    docker:
@@ -745,6 +754,7 @@ workflows:
      - "build-musl"
      - "build-arm64"
      - "build-centos7"
+      - "quality-static-analysis"
      - "tests-integration":
          requires:
            - "build-centos7"
@@ -757,78 +767,78 @@ workflows:
      - "tests-driver-loader-integration":
          requires:
            - "build-centos7"
-      # - "rpm-sign":
-      #     context: falco
-      #     filters:
-      #       tags:
-      #         ignore: /.*/
-      #       branches:
-      #         only: master
-      #     requires:
-      #       - "tests-integration"
-      #       - "tests-integration-arm64"
-      # - "publish-packages-dev":
-      #     context:
-      #       - falco
-      #       - test-infra
-      #     filters:
-      #       tags:
-      #         ignore: /.*/
-      #       branches:
-      #         only: master
-      #     requires:
-      #       - "rpm-sign"
-      #       - "tests-integration-static"
-      # - "publish-packages-deb-dev":
-      #     context:
-      #       - falco
-      #       - test-infra
-      #     filters:
-      #       tags:
-      #         ignore: /.*/
-      #       branches:
-      #         only: master
-      #     requires:
-      #       - "tests-integration"
-      #       - "tests-integration-arm64"
-      # - "build-docker-dev":
-      #     context:
-      #       - falco
-      #       - test-infra
-      #     filters:
-      #       tags:
-      #         ignore: /.*/
-      #       branches:
-      #         only: master
-      #     requires:
-      #       - "publish-packages-dev"
-      #       - "publish-packages-deb-dev"
-      #       - "tests-driver-loader-integration"
-      # - "build-docker-dev-arm64":
-      #     context:
-      #       - falco
-      #       - test-infra
-      #     filters:
-      #       tags:
-      #         ignore: /.*/
-      #       branches:
-      #         only: master
-      #     requires:
-      #       - "publish-packages-dev"
-      #       - "publish-packages-deb-dev"
-      #       - "tests-driver-loader-integration"      
-      # - "publish-docker-dev":
-      #     context:
-      #       - falco
-      #       - test-infra
-      #     filters:
-      #       tags:
-      #         ignore: /.*/
-      #       branches:
-      #         only: master
-      #     requires:
-      #       - "build-docker-dev"
-      #       - "build-docker-dev-arm64"
+      - "rpm-sign":
+          context: falco
+          filters:
+            tags:
+              ignore: /.*/
+            branches:
+              only: master
+          requires:
+            - "tests-integration"
+            - "tests-integration-arm64"
+      - "publish-packages-dev":
+          context:
+            - falco
+            - test-infra
+          filters:
+            tags:
+              ignore: /.*/
+            branches:
+              only: master
+          requires:
+            - "rpm-sign"
+            - "tests-integration-static"
+      - "publish-packages-deb-dev":
+          context:
+            - falco
+            - test-infra
+          filters:
+            tags:
+              ignore: /.*/
+            branches:
+              only: master
+          requires:
+            - "tests-integration"
+            - "tests-integration-arm64"
+      - "build-docker-dev":
+          context:
+            - falco
+            - test-infra
+          filters:
+            tags:
+              ignore: /.*/
+            branches:
+              only: master
+          requires:
+            - "publish-packages-dev"
+            - "publish-packages-deb-dev"
+            - "tests-driver-loader-integration"
+      - "build-docker-dev-arm64":
+          context:
+            - falco
+            - test-infra
+          filters:
+            tags:
+              ignore: /.*/
+            branches:
+              only: master
+          requires:
+            - "publish-packages-dev"
+            - "publish-packages-deb-dev"
+            - "tests-driver-loader-integration"      
+      - "publish-docker-dev":
+          context:
+            - falco
+            - test-infra
+          filters:
+            tags:
+              ignore: /.*/
+            branches:
+              only: master
+          requires:
+            - "build-docker-dev"
+            - "build-docker-dev-arm64"
      # - "quality/static-analysis" # This is temporarily disabled: https://github.com/falcosecurity/falco/issues/1526
  release:
    jobs:
@@ -850,73 +860,73 @@ workflows:
              only: /.*/
            branches:
              ignore: /.*/
-      # - "rpm-sign":
-      #     context: falco
-      #     requires:
-      #       - "build-centos7"
-      #       - "build-arm64"
-      #     filters:
-      #       tags:
-      #         only: /.*/
-      #       branches:
-      #         ignore: /.*/
-      # - "publish-packages":
-      #     context:
-      #       - falco
-      #       - test-infra
-      #     requires:
-      #       - "build-musl"
-      #       - "rpm-sign"
-      #     filters:
-      #       tags:
-      #         only: /.*/
-      #       branches:
-      #         ignore: /.*/
-      # - "publish-packages-deb":
-      #     context:
-      #       - falco
-      #       - test-infra
-      #     requires:
-      #       - "build-centos7"
-      #       - "build-arm64"
-      #     filters:
-      #       tags:
-      #         only: /.*/
-      #       branches:
-      #         ignore: /.*/
-      # - "build-docker":
-      #     context:
-      #       - falco
-      #       - test-infra
-      #     requires:
-      #       - "publish-packages"
-      #       - "publish-packages-deb"
-      #     filters:
-      #       tags:
-      #         only: /.*/
-      #       branches:
-      #         ignore: /.*/
-      # - "build-docker-arm64":
-      #     context:
-      #       - falco
-      #       - test-infra
-      #     requires:
-      #       - "publish-packages"
-      #       - "publish-packages-deb"
-      #     filters:
-      #       tags:
-      #         only: /.*/
-      #       branches:
-      #         ignore: /.*/
-      # - "publish-docker":
-      #     context:
-      #       - falco
-      #       - test-infra
-      #     requires:
-      #       - "build-docker"
-      #       - "build-docker-arm64"
-      #     filters:
-      #       tags:
-      #         only: /.*/
-      #       branches:
-      #         ignore: /.*/
+      - "rpm-sign":
+          context: falco
+          requires:
+            - "build-centos7"
+            - "build-arm64"
+          filters:
+            tags:
+              only: /.*/
+            branches:
+              ignore: /.*/
+      - "publish-packages":
+          context:
+            - falco
+            - test-infra
+          requires:
+            - "build-musl"
+            - "rpm-sign"
+          filters:
+            tags:
+              only: /.*/
+            branches:
+              ignore: /.*/
+      - "publish-packages-deb":
+          context:
+            - falco
+            - test-infra
+          requires:
+            - "build-centos7"
+            - "build-arm64"
+          filters:
+            tags:
+              only: /.*/
+            branches:
+              ignore: /.*/
+      - "build-docker":
+          context:
+            - falco
+            - test-infra
+          requires:
+            - "publish-packages"
+            - "publish-packages-deb"
+          filters:
+            tags:
+              only: /.*/
+            branches:
+              ignore: /.*/
+      - "build-docker-arm64":
+          context:
+            - falco
+            - test-infra
+          requires:
+            - "publish-packages"
+            - "publish-packages-deb"
+          filters:
+            tags:
+              only: /.*/
+            branches:
+              ignore: /.*/
+      - "publish-docker":
+          context:
+            - falco
+            - test-infra
+          requires:
+            - "build-docker"
+            - "build-docker-arm64"
+          filters:
+            tags:
+              only: /.*/
+            branches:
+              ignore: /.*/
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,7 +1,8 @@
-<!--  Thanks for sending a pull request! Here are some tips for you:
-1. If this is your first time, please read our contributor guidelines in the https://github.com/falcosecurity/.github/blob/main/CONTRIBUTING.md file.
+<!--  Thanks for sending a pull request!  Here are some tips for you:
+
+1. If this is your first time, please read our contributor guidelines in the [CONTRIBUTING.md](https://github.com/falcosecurity/.github/blob/master/CONTRIBUTING.md) file and learn how to compile Falco from source [here](https://falco.org/docs/source).
 2. Please label this pull request according to what type of issue you are addressing.
-3. Please add a release note!
+3. . Please add a release note!
 4. If the PR is unfinished while opening it specify a wip in the title before the actual title, for example, "wip: my awesome feature"
 -->

@@ -23,6 +24,12 @@

 > /kind release

+> If contributing rules or changes to rules, please make sure to also uncomment one of the following line:
+
+> /kind rule-update
+
+> /kind rule-create
+
 <!--
 Please remove the leading whitespace before the `/kind <>` you uncommented.
 -->
@@ -35,6 +42,8 @@ Please remove the leading whitespace before the `/kind <>` you uncommented.

 > /area engine

+> /area rules
+
 > /area tests

 > /area proposals
@@ -62,13 +71,11 @@ Fixes #
 **Does this PR introduce a user-facing change?**:

 <!--
-If NO, just write "NONE" in the release-note block below.
-
-If YES, a release note is required, enter your release note in the block below. 
-The convention is the same as for commit messages: https://github.com/falcosecurity/.github/blob/main/CONTRIBUTING.md#commit-convention
-If the PR introduces non-backward compatible changes, please add a line starting with "BREAKING CHANGE:" and describe what changed.
-For example, `BREAKING CHANGE: the API interface of the rule engine has changed`.
-Your note will be included in the changelog.
+If no, just write "NONE" in the release-note block below.
+If yes, a release note is required:
+Enter your extended release note in the block below.
+If the PR requires additional action from users switching to the new release, prepend the string "action required:".
+For example, `action required: change the API interface of the rule engine`.
 -->

 ```release-note
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,24 +0,0 @@
-#
-# Copyright (C) 2023 The Falco Authors.
-#
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-version: 2
-
-updates:
-  - package-ecosystem: gitsubmodule
-    schedule:
-      interval: "daily"
-    directory: /
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,14 +2,10 @@ name: CI Build
 on:
  pull_request:
    branches: [master]
+  push:
+    branches: [master]
  workflow_dispatch:

-# Checks if any concurrent jobs under the same pull request or branch are being executed
-# NOTE: this will cancel every workflow that is being ran against a PR as group is just the github ref (without the workflow name)
-concurrency:
-  group: ${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true  
-
 jobs:
  build-minimal:
    runs-on: ubuntu-20.04
@@ -30,7 +26,7 @@ jobs:
        run: |
          mkdir build-minimal
          pushd build-minimal
-          cmake -DMINIMAL_BUILD=On -DBUILD_BPF=Off -DBUILD_DRIVER=Off -DCMAKE_BUILD_TYPE=Release -DBUILD_FALCO_UNIT_TESTS=On ..
+          cmake -DMINIMAL_BUILD=On -DBUILD_BPF=Off -DBUILD_DRIVER=Off -DCMAKE_BUILD_TYPE=Release ..
          popd

      - name: Build
@@ -42,7 +38,7 @@ jobs:
      - name: Run unit tests
        run: |
          pushd build-minimal
-          sudo ./unit_tests/falco_unit_tests 
+          make tests
          popd

  build-ubuntu-focal:
@@ -64,7 +60,7 @@ jobs:
        run: |
          mkdir build
          pushd build
-          cmake -DBUILD_BPF=On -DCMAKE_BUILD_TYPE=Release -DBUILD_FALCO_UNIT_TESTS=On ..
+          cmake -DBUILD_BPF=On ..
          popd

      - name: Build
@@ -76,7 +72,7 @@ jobs:
      - name: Run unit tests
        run: |
          pushd build
-          sudo ./unit_tests/falco_unit_tests 
+          make tests
          popd

  build-ubuntu-focal-debug:
@@ -98,7 +94,7 @@ jobs:
        run: |
          mkdir build
          pushd build
-          cmake -DCMAKE_BUILD_TYPE=Debug -DBUILD_BPF=On -DBUILD_FALCO_UNIT_TESTS=On ..
+          cmake -DCMAKE_BUILD_TYPE=debug -DBUILD_BPF=On ..
          popd

      - name: Build
@@ -110,5 +106,70 @@ jobs:
      - name: Run unit tests
        run: |
          pushd build
-          sudo ./unit_tests/falco_unit_tests 
+          make tests
          popd
+
+  build-ubuntu-bionic:
+    runs-on: ubuntu-18.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          ref: ${{ github.event.pull_request.head.sha }}
+
+      - name: Update base image
+        run: sudo apt update -y
+
+      - name: Install build dependencies
+        run: sudo DEBIAN_FRONTEND=noninteractive apt install cmake build-essential clang llvm git linux-headers-$(uname -r) pkg-config autoconf libtool libelf-dev -y
+
+      - name: Prepare project
+        run: |
+          mkdir build
+          pushd build
+          cmake -DBUILD_BPF=On -DUSE_BUNDLED_DEPS=On ..
+          popd
+
+      - name: Build
+        run: |
+          pushd build
+          KERNELDIR=/lib/modules/$(uname -r)/build make -j4 all
+          popd
+
+      - name: Run unit tests
+        run: |
+          pushd build
+          make tests
+          popd
+
+  build-centos7-debug:
+    runs-on: ubuntu-latest
+    container:
+      image: falcosecurity/falco-builder:latest
+      env:
+        BUILD_TYPE: "debug"
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          path: falco
+          ref: ${{ github.event.pull_request.head.sha }}
+
+      - name: Link falco repo to /source/falco
+        run: |
+          mkdir -p /source
+          ln -s "$GITHUB_WORKSPACE/falco" /source/falco
+  
+      - name: Prepare project
+        run: /usr/bin/entrypoint cmake
+
+      - name: Build
+        run: /usr/bin/entrypoint all
+
+      - name: Run unit tests
+        run: /usr/bin/entrypoint tests
+
+      - name: Build packages
+        run: /usr/bin/entrypoint package
--- a/.github/workflows/images_bumper.yml
+++ b/.github/workflows/images_bumper.yml
@@ -1,64 +0,0 @@
-name: Builder and Tester Images Bumper
-
-on:
-  push:
-    branches: [master]
-
-jobs:
-  paths-filter:
-    runs-on: ubuntu-latest
-    outputs:
-      builder_changed: ${{ steps.filter.outputs.builder }}
-      tester_changed: ${{ steps.filter.outputs.tester }}
-    steps:
-    - uses: actions/checkout@v2
-    - uses: dorny/paths-filter@v2
-      id: filter
-      with:
-        filters: |
-          builder:
-            - 'docker/builder/**'
-          tester:
-            - 'docker/tester/**'
-
-  update-builder-tester-images:
-    runs-on: ubuntu-22.04
-    needs: paths-filter
-    if: needs.paths-filter.outputs.builder_changed == 'true' || needs.paths-filter.outputs.tester_changed == 'true'
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v1
-        with:
-          username: ${{ secrets.DOCKERHUB_USER }}
-          password: ${{ secrets.DOCKERHUB_SECRET }}
-          
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-        with:
-          platforms: 'amd64,arm64'
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-      
-      - name: Build and push new builder image
-        if: needs.paths-filter.outputs.builder_changed == 'true'
-        uses: docker/build-push-action@v3
-        with:
-          context: docker/builder
-          platforms: linux/amd64,linux/arm64
-          tags: latest
-          push: true
-
-      - name: Build and push new tester image
-        if: needs.paths-filter.outputs.tester_changed == 'true'
-        uses: docker/build-push-action@v3
-        with:
-          context: docker/tester
-          platforms: linux/amd64,linux/arm64
-          tags: latest
-          push: true
--- a/.github/workflows/master.yaml
+++ b/.github/workflows/master.yaml
@@ -1,93 +0,0 @@
-name: Dev Packages and Docker images
-on:
-  push:
-    branches: [master]
-
-# Checks if any concurrent jobs is running for master CI and eventually cancel it
-concurrency:
-  group: ci-master
-  cancel-in-progress: true  
-
-jobs:
-  # We need to use an ubuntu-latest to fetch Falco version because
-  # Falco version is computed by some cmake scripts that do git sorceries
-  # to get the current version.
-  # But centos7 jobs have a git version too old and actions/checkout does not 
-  # fully clone the repo, but uses http rest api instead.
-  fetch-version:
-    runs-on: ubuntu-latest
-    # Map the job outputs to step outputs
-    outputs:
-      version: ${{ steps.store_version.outputs.version }}  
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          
-      - name: Install build dependencies
-        run: |
-          sudo apt update 
-          sudo apt install -y cmake build-essential
-      
-      - name: Configure project
-        run: |
-          mkdir build && cd build
-          cmake -DUSE_BUNDLED_DEPS=On ..
-          
-      - name: Load and store Falco version output
-        id: store_version
-        run: |
-          FALCO_VERSION=$(cat build/userspace/falco/config_falco.h | grep 'FALCO_VERSION ' | cut -d' ' -f3 | sed -e 's/^"//' -e 's/"$//')
-          echo "version=${FALCO_VERSION}" >> $GITHUB_OUTPUT     
-
-  build-dev-packages:
-    needs: [fetch-version]
-    uses: falcosecurity/falco/.github/workflows/reusable_build_packages.yaml@master
-    with:
-      arch: x86_64
-      version: ${{ needs.fetch-version.outputs.version }}
-    secrets: inherit
-  
-  build-dev-packages-arm64:
-    needs: [fetch-version]
-    uses: falcosecurity/falco/.github/workflows/reusable_build_packages.yaml@master
-    with:
-      arch: aarch64
-      version: ${{ needs.fetch-version.outputs.version }}
-    secrets: inherit
-    
-  publish-dev-packages:
-    needs: [fetch-version, build-dev-packages, build-dev-packages-arm64]
-    uses: falcosecurity/falco/.github/workflows/reusable_publish_packages.yaml@master
-    with:
-      bucket_suffix: '-dev'
-      version: ${{ needs.fetch-version.outputs.version }}
-    secrets: inherit
-  
-  build-dev-docker:
-    needs: [fetch-version, publish-dev-packages]
-    uses: falcosecurity/falco/.github/workflows/reusable_build_docker.yaml@master
-    with:
-      arch: x86_64
-      bucket_suffix: '-dev'
-      version: ${{ needs.fetch-version.outputs.version }}
-      tag: master
-    secrets: inherit
-    
-  build-dev-docker-arm64:
-    needs: [fetch-version, publish-dev-packages]
-    uses: falcosecurity/falco/.github/workflows/reusable_build_docker.yaml@master
-    with:
-      arch: aarch64
-      bucket_suffix: '-dev'
-      version: ${{ needs.fetch-version.outputs.version }}
-      tag: master
-    secrets: inherit
-    
-  publish-dev-docker:
-    needs: [fetch-version, build-dev-docker, build-dev-docker-arm64]
-    uses: falcosecurity/falco/.github/workflows/reusable_publish_docker.yaml@master
-    with:
-      tag: master
-    secrets: inherit
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -1,105 +0,0 @@
-name: Release Packages and Docker images
-on:
-  release:
-    types: [published]
-
-# Checks if any concurrent jobs is running for release CI and eventually cancel it.
-concurrency:
-  group: ci-release
-  cancel-in-progress: true  
-
-jobs:
-  release-settings:
-    runs-on: ubuntu-latest
-    outputs:
-      is_latest: ${{ steps.get_settings.outputs.is_latest }} 
-      bucket_suffix: ${{ steps.get_settings.outputs.bucket_suffix }}
-    steps:
-      - name: Get latest release
-        uses: rez0n/actions-github-release@v2.0
-        id: latest_release
-        env:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          repository: ${{ github.repository }}
-          type: "stable"
-
-      - name: Get settings for this release
-        id: get_settings
-        shell: python
-        run: |
-          import os
-          import re
-          import sys
-
-          semver_no_meta = '''^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?$'''
-          tag_name = '${{ github.event.release.tag_name }}'
-
-          is_valid_version = re.match(semver_no_meta, tag_name) is not None
-          if not is_valid_version:
-            print(f'Release version {tag_name} is not a valid full or pre-release. See RELEASE.md for more information.')
-            sys.exit(1)
-
-          is_prerelease = '-' in tag_name
-
-          # Safeguard: you need to both set "latest" in GH and not have suffixes to overwrite latest
-          is_latest = '${{ steps.latest_release.outputs.release }}' == tag_name and not is_prerelease
-
-          bucket_suffix = '-dev' if is_prerelease else ''
-
-          with open(os.environ['GITHUB_OUTPUT'], 'a') as ofp:
-            print(f'is_latest={is_latest}'.lower(), file=ofp)
-            print(f'bucket_suffix={bucket_suffix}', file=ofp)
-
-  build-packages:
-    needs: [release-settings]
-    uses: falcosecurity/falco/.github/workflows/reusable_build_packages.yaml@master
-    with:
-      arch: x86_64
-      version: ${{ github.event.release.tag_name }}
-    secrets: inherit
-
-  build-packages-arm64:
-    needs: [release-settings]
-    uses: falcosecurity/falco/.github/workflows/reusable_build_packages.yaml@master
-    with:
-      arch: aarch64
-      version: ${{ github.event.release.tag_name }}
-    secrets: inherit
-    
-  publish-packages:
-    needs: [release-settings, build-packages, build-packages-arm64]
-    uses: falcosecurity/falco/.github/workflows/reusable_publish_packages.yaml@master
-    with:
-      bucket_suffix: ${{ needs.release-settings.outputs.bucket_suffix }}
-      version: ${{ github.event.release.tag_name }}
-    secrets: inherit
-  
-  # Both build-docker and its arm64 counterpart require build-packages because they use its output
-  build-docker:
-    needs: [release-settings, build-packages, publish-packages]
-    uses: falcosecurity/falco/.github/workflows/reusable_build_docker.yaml@master
-    with:
-      arch: x86_64
-      bucket_suffix: ${{ needs.release-settings.outputs.bucket_suffix }}
-      version: ${{ github.event.release.tag_name }}
-      tag: ${{ github.event.release.tag_name }}
-    secrets: inherit
-    
-  build-docker-arm64:
-    needs: [release-settings, build-packages, publish-packages]
-    uses: falcosecurity/falco/.github/workflows/reusable_build_docker.yaml@master
-    with:
-      arch: aarch64
-      bucket_suffix: ${{ needs.release-settings.outputs.bucket_suffix }}
-      version: ${{ github.event.release.tag_name }}
-      tag: ${{ github.event.release.tag_name }}
-    secrets: inherit
-
-  publish-docker:
-    needs: [release-settings, build-docker, build-docker-arm64]
-    uses: falcosecurity/falco/.github/workflows/reusable_publish_docker.yaml@master
-    secrets: inherit
-    with:
-      is_latest: ${{ needs.release-settings.outputs.is_latest == 'true' }}
-      tag: ${{ github.event.release.tag_name }}
-      sign: true
--- a/.github/workflows/reusable_build_docker.yaml
+++ b/.github/workflows/reusable_build_docker.yaml
@@ -1,79 +0,0 @@
-# This is a reusable workflow used by master and release CI
-on:
-  workflow_call:
-    inputs:
-      arch:
-        description: x86_64 or aarch64
-        required: true
-        type: string
-      bucket_suffix:
-        description: bucket suffix for packages
-        required: false
-        default: ''
-        type: string
-      version:
-        description: The Falco version to use when building images
-        required: true
-        type: string
-      tag:
-        description: The tag to use (e.g. "master" or "0.35.0")
-        required: true
-        type: string
-
-# Here we just build all docker images as tarballs, 
-# then we upload all the tarballs to be later downloaded by reusable_publish_docker workflow.
-# In this way, we don't need to publish any arch specific image, 
-# and this "build" workflow is actually only building images.
-jobs:
-  build-docker:
-    # See https://github.com/actions/runner/issues/409#issuecomment-1158849936
-    runs-on: ${{ (inputs.arch == 'aarch64' && fromJSON('[ "self-hosted", "linux", "ARM64" ]')) || 'ubuntu-latest' }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-          
-      - name: Build no-driver image
-        uses: docker/build-push-action@v3
-        with:
-          context: ${{ github.workspace }}/docker/no-driver/
-          build-args: |
-            VERSION_BUCKET=bin${{ inputs.bucket_suffix }}
-            FALCO_VERSION=${{ inputs.version }}
-          tags: |
-            docker.io/falcosecurity/falco-no-driver:${{ inputs.arch }}-${{ inputs.tag }}
-          outputs: type=docker,dest=/tmp/falco-no-driver-${{ inputs.arch }}.tar
-            
-      - name: Build falco image
-        uses: docker/build-push-action@v3
-        with:
-          context: ${{ github.workspace }}/docker/falco/
-          build-args: |
-            VERSION_BUCKET=deb${{ inputs.bucket_suffix }}
-            FALCO_VERSION=${{ inputs.version }}
-          tags: |
-            docker.io/falcosecurity/falco:${{ inputs.arch }}-${{ inputs.tag }}
-          outputs: type=docker,dest=/tmp/falco-${{ inputs.arch }}.tar
-
-      # The falcosecurity/falco image is required for the driver-loader image, so we need to load it
-      - name: Load the falcosecurity/falco image
-        run: |
-          docker load --input /tmp/falco-${{ inputs.arch }}.tar
-
-      - name: Build falco-driver-loader image
-        uses: docker/build-push-action@v3
-        with:
-          context: ${{ github.workspace }}/docker/driver-loader/
-          build-args: |
-            FALCO_IMAGE_TAG=${{ inputs.arch }}-${{ inputs.tag }}
-          tags: |
-            docker.io/falcosecurity/falco-driver-loader:${{ inputs.arch }}-${{ inputs.tag }}
-          outputs: type=docker,dest=/tmp/falco-driver-loader-${{ inputs.arch }}.tar  
-            
-      - name: Upload images tarballs
-        uses: actions/upload-artifact@v3
-        with:
-          name: falco-images
-          path: /tmp/falco-*.tar
--- a/.github/workflows/reusable_build_packages.yaml
+++ b/.github/workflows/reusable_build_packages.yaml
@@ -1,160 +0,0 @@
-# This is a reusable workflow used by master and release CI
-on:
-  workflow_call:
-    inputs:
-      arch:
-        description: x86_64 or aarch64
-        required: true
-        type: string
-      version:
-        description: The Falco version to use when building packages
-        required: true
-        type: string
-
-jobs:
-  build-modern-bpf-skeleton:
-    # See https://github.com/actions/runner/issues/409#issuecomment-1158849936
-    runs-on: ${{ (inputs.arch == 'aarch64' && fromJSON('[ "self-hosted", "linux", "ARM64" ]')) || 'ubuntu-latest' }}
-    container: fedora:latest
-    steps:
-      # Always install deps before invoking checkout action, to properly perform a full clone.
-      - name: Install build dependencies
-        run: |
-          dnf install -y bpftool ca-certificates cmake make automake gcc gcc-c++ kernel-devel clang git pkg-config autoconf automake libbpf-devel
-    
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Build modern BPF skeleton
-        run: |
-          mkdir skeleton-build && cd skeleton-build
-          cmake -DUSE_BUNDLED_DEPS=ON -DBUILD_FALCO_MODERN_BPF=ON -DCREATE_TEST_TARGETS=Off -DFALCO_VERSION=${{ inputs.version }} ..
-          make ProbeSkeleton -j6
-          
-      - name: Upload skeleton
-        uses: actions/upload-artifact@v3
-        with:
-          name: bpf_probe_${{ inputs.arch }}.skel.h
-          path: skeleton-build/skel_dir/bpf_probe.skel.h
-          
-  build-packages:
-    # See https://github.com/actions/runner/issues/409#issuecomment-1158849936
-    runs-on: ${{ (inputs.arch == 'aarch64' && fromJSON('[ "self-hosted", "linux", "ARM64" ]')) || 'ubuntu-latest' }}
-    needs: [build-modern-bpf-skeleton]
-    container: centos:7
-    steps:
-      # Always install deps before invoking checkout action, to properly perform a full clone.
-      - name: Install build dependencies
-        run: |
-          yum -y install centos-release-scl
-          yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++
-          source /opt/rh/devtoolset-9/enable
-          yum install -y wget git make m4 rpm-build
-    
-      - name: Checkout
-        uses: actions/checkout@v3
-    
-      - name: Download skeleton
-        uses: actions/download-artifact@v3
-        with:
-          name: bpf_probe_${{ inputs.arch }}.skel.h
-          path: /tmp
-          
-      - name: Install updated cmake
-        run: |
-          curl -L -o /tmp/cmake.tar.gz https://github.com/Kitware/CMake/releases/download/v3.22.5/cmake-3.22.5-linux-$(uname -m).tar.gz
-          gzip -d /tmp/cmake.tar.gz
-          tar -xpf /tmp/cmake.tar --directory=/tmp
-          cp -R /tmp/cmake-3.22.5-linux-$(uname -m)/* /usr
-          rm -rf /tmp/cmake-3.22.5-linux-$(uname -m)
-    
-      - name: Prepare project
-        run: |
-          mkdir build && cd build
-          source /opt/rh/devtoolset-9/enable
-          cmake \
-              -DCMAKE_BUILD_TYPE=Release \
-              -DUSE_BUNDLED_DEPS=On \
-              -DFALCO_ETC_DIR=/etc/falco \
-              -DBUILD_FALCO_MODERN_BPF=ON \
-              -DMODERN_BPF_SKEL_DIR=/tmp \
-              -DBUILD_DRIVER=Off \
-              -DBUILD_BPF=Off \
-              -DFALCO_VERSION=${{ inputs.version }} \
-              ..
-              
-      - name: Build project
-        run: |
-          cd build
-          source /opt/rh/devtoolset-9/enable
-          make falco -j6
-      
-      - name: Build packages
-        run: |
-          cd build
-          source /opt/rh/devtoolset-9/enable
-          make package
-
-      - name: Upload Falco tar.gz package
-        uses: actions/upload-artifact@v3
-        with:
-          name: falco-${{ inputs.version }}-${{ inputs.arch }}.tar.gz
-          path: |
-            ${{ github.workspace }}/build/falco-*.tar.gz
-            
-      - name: Upload Falco deb package
-        uses: actions/upload-artifact@v3
-        with:
-          name: falco-${{ inputs.version }}-${{ inputs.arch }}.deb
-          path: |
-            ${{ github.workspace }}/build/falco-*.deb
-      
-      - name: Upload Falco rpm package
-        uses: actions/upload-artifact@v3
-        with:
-          name: falco-${{ inputs.version }}-${{ inputs.arch }}.rpm
-          path: |
-            ${{ github.workspace }}/build/falco-*.rpm
-            
-  build-musl-package:
-    # x86_64 only for now
-    if: ${{ inputs.arch == 'x86_64' }}
-    runs-on: ubuntu-latest
-    container: alpine:3.17
-    steps:
-      # Always install deps before invoking checkout action, to properly perform a full clone.
-      - name: Install build dependencies
-        run: |
-          apk add g++ gcc cmake make git bash perl linux-headers autoconf automake m4 libtool elfutils-dev libelf-static patch binutils bpftool clang
-    
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          
-      - name: Prepare project
-        run: |
-          mkdir build && cd build
-          cmake -DCPACK_GENERATOR=TGZ -DBUILD_BPF=Off -DBUILD_DRIVER=Off -DCMAKE_BUILD_TYPE=Release -DUSE_BUNDLED_DEPS=On -DUSE_BUNDLED_LIBELF=Off -DBUILD_LIBSCAP_MODERN_BPF=ON -DMUSL_OPTIMIZED_BUILD=On -DFALCO_ETC_DIR=/etc/falco ../ -DFALCO_VERSION=${{ inputs.version }}
-          
-      - name: Build project
-        run: |
-          cd build
-          make -j6 all
-      
-      - name: Build packages
-        run: |
-          cd build
-          make -j6 package
-
-      - name: Rename static package
-        run: |
-          cd build
-          mv falco-${{ inputs.version }}-x86_64.tar.gz falco-${{ inputs.version }}-static-x86_64.tar.gz 
-          
-      - name: Upload Falco static package
-        uses: actions/upload-artifact@v3
-        with:
-          name: falco-${{ inputs.version }}-static-x86_64.tar.gz
-          path: |
-            ${{ github.workspace }}/build/falco-${{ inputs.version }}-static-x86_64.tar.gz
--- a/.github/workflows/reusable_publish_docker.yaml
+++ b/.github/workflows/reusable_publish_docker.yaml
@@ -1,144 +0,0 @@
-# This is a reusable workflow used by master and release CI
-on:
-  workflow_call:
-    inputs:
-      tag:
-        description: The tag to push
-        required: true
-        type: string
-      is_latest:
-        description: Update the latest tag with the new image
-        required: false
-        type: boolean
-        default: false
-      sign:
-        description: Add signature with cosign
-        required: false
-        type: boolean
-        default: false
-
-permissions:
-  id-token: write
-  contents: read
-  
-jobs:
-  publish-docker:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-    
-      - name: Download images tarballs
-        uses: actions/download-artifact@v3
-        with:
-          name: falco-images
-          path: /tmp/falco-images
-      
-      - name: Load all images
-        run: |
-          for img in /tmp/falco-images/falco-*.tar; do docker load --input $img; done
-    
-      - name: Login to Docker Hub
-        uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKERHUB_USER }}
-          password: ${{ secrets.DOCKERHUB_SECRET }}
-      
-      - name: Configure AWS credentials
-        uses: aws-actions/configure-aws-credentials@v2
-        with:
-          role-to-assume: "arn:aws:iam::292999226676:role/github_actions-falco-ecr"
-          aws-region: us-east-1 # The region must be set to us-east-1 in order to access ECR Public.
-          
-      - name: Login to Amazon ECR
-        id: login-ecr-public
-        uses: aws-actions/amazon-ecr-login@2f9f10ea3fa2eed41ac443fee8bfbd059af2d0a4 # v1.6.0
-        with:
-          registry-type: public    
-      
-      - name: Setup Crane
-        uses: imjasonh/setup-crane@v0.3
-        with:
-          version: v0.15.1
-
-      # We're pushing the arch-specific manifests to Docker Hub so that we'll be able to easily create the index/multiarch later
-      - name: Push arch-specific images to Docker Hub
-        run: |
-          docker push docker.io/falcosecurity/falco-no-driver:aarch64-${{ inputs.tag }}
-          docker push docker.io/falcosecurity/falco-no-driver:x86_64-${{ inputs.tag }}
-          docker push docker.io/falcosecurity/falco:aarch64-${{ inputs.tag }}
-          docker push docker.io/falcosecurity/falco:x86_64-${{ inputs.tag }}
-          docker push docker.io/falcosecurity/falco-driver-loader:aarch64-${{ inputs.tag }}
-          docker push docker.io/falcosecurity/falco-driver-loader:x86_64-${{ inputs.tag }}
-
-      - name: Create no-driver manifest on Docker Hub
-        uses: Noelware/docker-manifest-action@0.3.1
-        with:
-          inputs: docker.io/falcosecurity/falco-no-driver:${{ inputs.tag }}
-          images: docker.io/falcosecurity/falco-no-driver:aarch64-${{ inputs.tag }},docker.io/falcosecurity/falco-no-driver:x86_64-${{ inputs.tag }}
-          push: true
-          
-      - name: Tag slim manifest on Docker Hub
-        run: |
-          crane copy docker.io/falcosecurity/falco-no-driver:${{ inputs.tag }} docker.io/falcosecurity/falco:${{ inputs.tag }}-slim
-
-      - name: Create falco manifest on Docker Hub
-        uses: Noelware/docker-manifest-action@0.3.1
-        with:
-          inputs: docker.io/falcosecurity/falco:${{ inputs.tag }}
-          images: docker.io/falcosecurity/falco:aarch64-${{ inputs.tag }},docker.io/falcosecurity/falco:x86_64-${{ inputs.tag }}
-          push: true
-          
-      - name: Create falco-driver-loader manifest on Docker Hub
-        uses: Noelware/docker-manifest-action@0.3.1
-        with:
-          inputs: docker.io/falcosecurity/falco-driver-loader:${{ inputs.tag }}
-          images: docker.io/falcosecurity/falco-driver-loader:aarch64-${{ inputs.tag }},docker.io/falcosecurity/falco-driver-loader:x86_64-${{ inputs.tag }}
-          push: true
-
-      - name: Get Digests for images
-        id: digests
-        run: |
-          echo "falco-no-driver=$(crane digest docker.io/falcosecurity/falco-no-driver:${{ inputs.version }})" >> $GITHUB_OUTPUT
-          echo "falco=$(crane digest docker.io/falcosecurity/falco:${{ inputs.version }})" >> $GITHUB_OUTPUT
-          echo "falco-driver-loader=$(crane digest docker.io/falcosecurity/falco-driver-loader:${{ inputs.version }})" >> $GITHUB_OUTPUT
-
-      - name: Publish images to ECR
-        run: |
-          crane copy docker.io/falcosecurity/falco-no-driver:${{ inputs.tag }} public.ecr.aws/falcosecurity/falco-no-driver:${{ inputs.tag }}
-          crane copy docker.io/falcosecurity/falco:${{ inputs.tag }} public.ecr.aws/falcosecurity/falco:${{ inputs.tag }}
-          crane copy docker.io/falcosecurity/falco-driver-loader:${{ inputs.tag }} public.ecr.aws/falcosecurity/falco-driver-loader:${{ inputs.tag }}
-          crane copy public.ecr.aws/falcosecurity/falco-no-driver:${{ inputs.tag }} public.ecr.aws/falcosecurity/falco:${{ inputs.tag }}-slim
-
-      - name: Tag latest on Docker Hub and ECR
-        if: inputs.is_latest
-        run: |
-          crane tag docker.io/falcosecurity/falco-no-driver:${{ inputs.tag }} latest
-          crane tag docker.io/falcosecurity/falco:${{ inputs.tag }} latest
-          crane tag docker.io/falcosecurity/falco-driver-loader:${{ inputs.tag }} latest
-          crane tag docker.io/falcosecurity/falco:${{ inputs.tag }}-slim latest-slim
-
-          crane tag public.ecr.aws/falcosecurity/falco-no-driver:${{ inputs.tag }} latest
-          crane tag public.ecr.aws/falcosecurity/falco:${{ inputs.tag }} latest
-          crane tag public.ecr.aws/falcosecurity/falco-driver-loader:${{ inputs.tag }} latest
-          crane tag public.ecr.aws/falcosecurity/falco:${{ inputs.tag }}-slim latest-slim
-
-      - name: Setup Cosign
-        if: inputs.sign
-        uses: sigstore/cosign-installer@main
-        with:
-          cosign-release: v2.0.2
-
-      - name: Sign images with cosign
-        if: inputs.sign
-        env:
-          COSIGN_EXPERIMENTAL: "true"
-          COSIGN_YES: "true"
-        run: |
-          cosign sign docker.io/falcosecurity/falco-no-driver@${{ steps.digests.outputs.falco-no-driver }}
-          cosign sign docker.io/falcosecurity/falco@${{ steps.digests.outputs.falco }}
-          cosign sign docker.io/falcosecurity/falco-driver-loader@${{ steps.digests.outputs.falco-driver-loader }}
-
-          cosign sign public.ecr.aws/falcosecurity/falco-no-driver@${{ steps.digests.outputs.falco-no-driver }}
-          cosign sign public.ecr.aws/falcosecurity/falco@${{ steps.digests.outputs.falco }}
-          cosign sign public.ecr.aws/falcosecurity/falco-driver-loader@${{ steps.digests.outputs.falco-driver-loader }}
--- a/.github/workflows/reusable_publish_packages.yaml
+++ b/.github/workflows/reusable_publish_packages.yaml
@@ -1,150 +0,0 @@
-# This is a reusable workflow used by master and release CI
-on:
-  workflow_call:
-    inputs:
-      version:
-        description: The Falco version to use when publishing packages
-        required: true
-        type: string
-      bucket_suffix:
-        description: bucket suffix for packages
-        required: false
-        default: ''
-        type: string
-       
-permissions:
-  id-token: write
-  contents: read
-
-env:
-  AWS_S3_REGION: eu-west-1
-  AWS_CLOUDFRONT_DIST_ID: E1CQNPFWRXLGQD
-
-jobs:
-  publish-packages:
-    runs-on: ubuntu-latest
-    container: docker.io/centos:7
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-    
-      - name: Install dependencies
-        run: |
-          yum install epel-release -y
-          yum update -y
-          yum install rpm-sign expect which createrepo gpg python python-pip -y
-          pip install awscli==1.19.47
-
-      # Configure AWS role; see https://github.com/falcosecurity/test-infra/pull/1102
-      # Note: master CI can only push dev packages as we have 2 different roles for master and release.
-      - name: Configure AWS credentials
-        uses: aws-actions/configure-aws-credentials@v2
-        with:
-          role-to-assume: "arn:aws:iam::292999226676:role/github_actions-falco${{ inputs.bucket_suffix }}-s3"
-          aws-region: ${{ env.AWS_S3_REGION }}    
-          
-      - name: Download RPM x86_64
-        uses: actions/download-artifact@v3
-        with:
-          name: falco-${{ inputs.version }}-x86_64.rpm
-          path: /tmp/falco-rpm
-
-      - name: Download RPM aarch64
-        uses: actions/download-artifact@v3
-        with:
-          name: falco-${{ inputs.version }}-aarch64.rpm
-          path: /tmp/falco-rpm
-
-      - name: Download binary x86_64
-        uses: actions/download-artifact@v3
-        with:
-          name: falco-${{ inputs.version }}-x86_64.tar.gz
-          path: /tmp/falco-bin
-
-      - name: Download binary aarch64
-        uses: actions/download-artifact@v3
-        with:
-          name: falco-${{ inputs.version }}-aarch64.tar.gz
-          path: /tmp/falco-bin
-
-      - name: Download static binary x86_64
-        uses: actions/download-artifact@v3
-        with:
-          name: falco-${{ inputs.version }}-static-x86_64.tar.gz
-          path: /tmp/falco-bin-static
-        
-      - name: Import gpg key 
-        env:
-          GPG_KEY: ${{ secrets.GPG_KEY }}
-        run: printenv GPG_KEY | gpg --import -
-        
-      - name: Sign rpms
-        run: |
-          echo "%_signature gpg" > ~/.rpmmacros
-          echo "%_gpg_name  Falcosecurity Package Signing" >> ~/.rpmmacros
-          echo "%__gpg_sign_cmd %{__gpg} --force-v3-sigs --batch --no-armor --passphrase-fd 3 --no-secmem-warning -u \"%{_gpg_name}\" -sb --digest-algo sha256 %{__plaintext_filename}'" >> ~/.rpmmacros
-          cat > ~/sign <<EOF
-          #!/usr/bin/expect -f
-          spawn rpmsign --addsign {*}\$argv
-          expect -exact "Enter pass phrase: "
-          send -- "\n"
-          expect eof
-          EOF
-          chmod +x ~/sign
-          ~/sign /tmp/falco-rpm/falco-*.rpm
-          rpm --qf %{SIGPGP:pgpsig} -qp /tmp/falco-rpm/falco-*.rpm | grep SHA256
-          
-      - name: Publish rpm
-        run: |
-          ./scripts/publish-rpm -f /tmp/falco-rpm/falco-${{ inputs.version }}-x86_64.rpm -f /tmp/falco-rpm/falco-${{ inputs.version }}-aarch64.rpm -r rpm${{ inputs.bucket_suffix }}
-      
-      - name: Publish bin
-        run: |
-          ./scripts/publish-bin -f /tmp/falco-bin/falco-${{ inputs.version }}-x86_64.tar.gz -r bin${{ inputs.bucket_suffix }} -a x86_64
-          ./scripts/publish-bin -f /tmp/falco-bin/falco-${{ inputs.version }}-aarch64.tar.gz -r bin${{ inputs.bucket_suffix }} -a aarch64
-          
-      - name: Publish static
-        run: |
-          ./scripts/publish-bin -f /tmp/falco-bin-static/falco-${{ inputs.version }}-static-x86_64.tar.gz -r bin${{ inputs.bucket_suffix }} -a x86_64
-          
-  publish-packages-deb:
-    runs-on: ubuntu-latest
-    container: docker.io/debian:stable
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-    
-      - name: Install dependencies
-        run: |
-          apt update -y
-          apt-get install apt-utils bzip2 gpg python python3-pip -y
-          pip install awscli
-      
-      # Configure AWS role; see https://github.com/falcosecurity/test-infra/pull/1102
-      # Note: master CI can only push dev packages as we have 2 different roles for master and release.
-      - name: Configure AWS credentials
-        uses: aws-actions/configure-aws-credentials@v2
-        with:
-          role-to-assume: "arn:aws:iam::292999226676:role/github_actions-falco${{ inputs.bucket_suffix }}-s3"
-          aws-region: ${{ env.AWS_S3_REGION }}     
-      
-      - name: Download deb x86_64
-        uses: actions/download-artifact@v3
-        with:
-          name: falco-${{ inputs.version }}-x86_64.deb
-          path: /tmp/falco-deb
-
-      - name: Download deb aarch64
-        uses: actions/download-artifact@v3
-        with:
-          name: falco-${{ inputs.version }}-aarch64.deb
-          path: /tmp/falco-deb
-
-      - name: Import gpg key 
-        env:
-          GPG_KEY: ${{ secrets.GPG_KEY }}
-        run: printenv GPG_KEY | gpg --import -
-          
-      - name: Publish deb
-        run: |
-          ./scripts/publish-deb -f /tmp/falco-deb/falco-${{ inputs.version }}-x86_64.deb -f /tmp/falco-deb/falco-${{ inputs.version }}-aarch64.deb -r deb${{ inputs.bucket_suffix }}
--- a/.github/workflows/staticanalysis.yaml
+++ b/.github/workflows/staticanalysis.yaml
@@ -1,31 +0,0 @@
-name: StaticAnalysis
-on:
-  pull_request:
-jobs:
-  staticanalysis:
-    runs-on: ubuntu-22.04
-
-    steps:
-      - name: Checkout ⤵️
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          ref: ${{ github.event.pull_request.head.sha }}
-
-      - name: Install build dependencies ⛓️
-        run: |
-          sudo apt update -y
-          sudo apt install build-essential git cppcheck cmake -y
-
-      - name: Build and run cppcheck 🏎️
-        run: |
-          mkdir build
-          cd build && cmake -DUSE_BUNDLED_DEPS=On -DBUILD_WARNINGS_AS_ERRORS=ON -DCREATE_TEST_TARGETS=Off -DCMAKE_BUILD_TYPE="release" -DBUILD_BPF=Off -DBUILD_DRIVER=Off ..
-          make -j4 cppcheck
-          make -j4 cppcheck_htmlreport
-
-      - name: Upload reports ⬆️
-        uses: actions/upload-artifact@v3
-        with:
-          name: static-analysis-reports
-          path: ./build/static-analysis-reports
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,4 +0,0 @@
-[submodule "submodules/falcosecurity-rules"]
-	path = submodules/falcosecurity-rules
-	url = https://github.com/falcosecurity/rules.git
-	branch = main
--- a/ADOPTERS.md
+++ b/ADOPTERS.md
@@ -24,8 +24,6 @@ This is a list of production adopters of Falco (in alphabetical order):

 * [Coveo](https://www.coveo.com/) - Coveo stitches together content and data, learning from every interaction, to tailor every experience using AI to drive growth, satisfy customers and develop employee proficiency. All Falco events are centralized in our SIEM for analysis. Understanding what is running on production servers, and the context around why things are running is even more tricky now that we have further abstractions with containers and orchestration systems. Falco is giving us a good visibility inside containers and complement other Host and Network Intrusion Detection Systems. In a near future, we expect to deploy serverless functions to take action when Falco identifies patterns worth taking action for.

-* [Deckhouse](https://deckhouse.io/) - Deckhouse Platform presents to you the opportunity to create homogeneous Kubernetes clusters anywhere and handles comprehensive, automagical management for them. It supplies all the add-ons you need for auto-scaling, observability, security, and service mesh. Falco is used as a part of the [runtime-audit-engine](https://deckhouse.io/documentation/latest/modules/650-runtime-audit-engine/) module to provide threats detection and enforce security compliance out of the box. By pairing with [shell-operator](https://github.com/flant/shell-operator) Falco can be configured by Kubernetes Custom Resources.
-
 * [Fairwinds](https://fairwinds.com/) - [Fairwinds Insights](https://fairwinds.com/insights), Kubernetes governance software, integrates Falco to offer a single pane of glass view into potential security incidents. Insights adds out-of-the-box integrations and rules filter to reduce alert fatigue and improve security response. The platform adds security prevention, detection, and response capabilities to your existing Kubernetes infrastructure. Security and DevOps teams benefit from a centralized view of container security vulnerability scanning and runtime container security.

 * [Frame.io](https://frame.io/) - Frame.io is a cloud-based (SaaS) video review and collaboration platform that enables users to securely upload source media, work-in-progress edits, dailies, and more into private workspaces where they can invite their team and clients to collaborate on projects. Understanding what is running on production servers, and the context around why things are running is even more tricky now that we have further abstractions like Docker and Kubernetes. To get this needed visibility into our system, we rely on Falco. Falco's ability to collect raw system calls such as open, connect, exec, along with their arguments offer key insights on what is happening on the production system and became the foundation of our intrusion detection and alerting system.
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,123 +1,5 @@
 # Change Log

-## v0.34.1
-
-Released on 2023-02-20
-
-### Minor Changes
-
-* fix(userspace/engine): correctly bump FALCO_ENGINE_VERSION after introduction of new fields [[#2418](https://github.com/falcosecurity/falco/pull/2418)] - [@loresuso](https://github.com/loresuso/)
-
-### Non user-facing changes
-
-* fix(dockerfile/no-driver): install ca-certificates [[#2412](https://github.com/falcosecurity/falco/pull/2412)] - [@alacuku](https://github.com/alacuku)
-
-## v0.34.0
-
-Released on 2023-02-07
-
-### Major Changes
-
-* BREAKING CHANGE: if you relied upon `application_rules.yaml` you can download it from https://github.com/falcosecurity/rules/tree/main/rules and manually install it. [[#2389](https://github.com/falcosecurity/falco/pull/2389)] - [@leogr](https://github.com/leogr)
-
-* new(rules): New rule to detect attempts to inject code into a process using PTRACE [[#2226](https://github.com/falcosecurity/falco/pull/2226)] - [@Brucedh](https://github.com/Brucedh)
-* new(engine): Also include exact locations for rule condition compile errors (missing macros, etc). [[#2216](https://github.com/falcosecurity/falco/pull/2216)] - [@mstemm](https://github.com/mstemm)
-* new(scripts): Support older RHEL distros in falco-driver-loader script [[#2312](https://github.com/falcosecurity/falco/pull/2312)] - [@gentooise](https://github.com/gentooise)
-* new(scripts): add `falcoctl` config into Falco package [[#2390](https://github.com/falcosecurity/falco/pull/2390)] - [@Andreagit97](https://github.com/Andreagit97)
-* new(userspace/falco): [EXPERIMENTAL] allow modern bpf probe to assign more than one CPU to a single ring buffer [[#2363](https://github.com/falcosecurity/falco/pull/2363)] - [@Andreagit97](https://github.com/Andreagit97)
-* new(userspace/falco): add webserver endpoint for retrieving internal version numbers [[#2356](https://github.com/falcosecurity/falco/pull/2356)] - [@jasondellaluce](https://github.com/jasondellaluce)
-* new(falco): add --version-json to print version information in json format [[#2331](https://github.com/falcosecurity/falco/pull/2331)] - [@LucaGuerra](https://github.com/LucaGuerra)
-* new(scripts): support multiple drivers in systemd units [[#2242](https://github.com/falcosecurity/falco/pull/2242)] - [@FedeDP](https://github.com/FedeDP)
-* new(scripts): add bottlerocket support in falco-driver-loader [[#2318](https://github.com/falcosecurity/falco/pull/2318)] - [@FedeDP](https://github.com/FedeDP)
-* new(falco): add more version fields to --support and --version [[#2325](https://github.com/falcosecurity/falco/pull/2325)] - [@LucaGuerra](https://github.com/LucaGuerra)
-* new(config): explicitly add the `simulate_drops` config [[#2260](https://github.com/falcosecurity/falco/pull/2260)] - [@Andreagit97](https://github.com/Andreagit97)
-
-
-### Minor Changes
-
-* build: upgrade to `falcoctl` v0.4.0 [[#2406](https://github.com/falcosecurity/falco/pull/2406)] - [@loresuso](https://github.com/loresuso)
-* update(userspace): change `modern_bpf.cpus_for_each_syscall_buffer` default value [[#2404](https://github.com/falcosecurity/falco/pull/2404)] - [@Andreagit97](https://github.com/Andreagit97)
-* update(build): update falcoctl to 0.3.0 [[#2401](https://github.com/falcosecurity/falco/pull/2401)] - [@LucaGuerra](https://github.com/LucaGuerra)
-* update(build): update falcoctl to 0.3.0-rc7 [[#2396](https://github.com/falcosecurity/falco/pull/2396)] - [@LucaGuerra](https://github.com/LucaGuerra)
-* update(cmake): bump libs to 0.10.3 [[#2392](https://github.com/falcosecurity/falco/pull/2392)] - [@FedeDP](https://github.com/FedeDP)
-* build: `/etc/falco/rules.available` has been deprecated [[#2389](https://github.com/falcosecurity/falco/pull/2389)] - [@leogr](https://github.com/leogr)
-* build: `application_rules.yaml` is not shipped anymore with Falco [[#2389](https://github.com/falcosecurity/falco/pull/2389)] - [@leogr](https://github.com/leogr)
-* build: upgrade k8saudit plugin to v0.5.0 [[#2381](https://github.com/falcosecurity/falco/pull/2381)] - [@leogr](https://github.com/leogr)
-* build: upgrade cloudtrail plugin to v0.6.0 [[#2381](https://github.com/falcosecurity/falco/pull/2381)] - [@leogr](https://github.com/leogr)
-* new!: ship falcoctl inside Falco [[#2345](https://github.com/falcosecurity/falco/pull/2345)] - [@FedeDP](https://github.com/FedeDP)
-* refactor: remove rules and add submodule to falcosecurity/rules [[#2359](https://github.com/falcosecurity/falco/pull/2359)] - [@jasondellaluce](https://github.com/jasondellaluce)
-* update(scripts): add option for regenerating signatures of all dev and release packages [[#2364](https://github.com/falcosecurity/falco/pull/2364)] - [@jasondellaluce](https://github.com/jasondellaluce)
-* update: print JSON version output when json_output is enabled [[#2351](https://github.com/falcosecurity/falco/pull/2351)] - [@jasondellaluce](https://github.com/jasondellaluce)
-* update(cmake): updated libs to 0.10.1 tag. [[#2362](https://github.com/falcosecurity/falco/pull/2362)] - [@FedeDP](https://github.com/FedeDP)
-* Install the certificates of authorities in falco:no-driver docker image [[#2355](https://github.com/falcosecurity/falco/pull/2355)] - [@Issif](https://github.com/Issif)
-* update: Mesos support is now deprecated and will be removed in the next version. [[#2328](https://github.com/falcosecurity/falco/pull/2328)] - [@leogr](https://github.com/leogr)
-* update(scripts/falco-driver-loader): optimize the resiliency of module download script for air-gapped environments [[#2336](https://github.com/falcosecurity/falco/pull/2336)] - [@Dentrax](https://github.com/Dentrax)
-* doc(userspace): provide users with a correct message when some syscalls are not defined [[#2329](https://github.com/falcosecurity/falco/pull/2329)] - [@Andreagit97](https://github.com/Andreagit97)
-* update(ci): update ci jobs to generate Falco images with the modern BPF probe [[#2320](https://github.com/falcosecurity/falco/pull/2320)] - [@Andreagit97](https://github.com/Andreagit97)
-* rules: add Falco container lists [[#2290](https://github.com/falcosecurity/falco/pull/2290)] - [@oscr](https://github.com/oscr)
-* rules(macro: private_key_or_password): now also check for OpenSSH private keys [[#2284](https://github.com/falcosecurity/falco/pull/2284)] - [@oscr](https://github.com/oscr)
-* update(cmake): bump libs and driver to latest RC. [[#2302](https://github.com/falcosecurity/falco/pull/2302)] - [@FedeDP](https://github.com/FedeDP)
-* Ensure that a ruleset object is copied properly in falco_engine::add_source(). [[#2271](https://github.com/falcosecurity/falco/pull/2271)] - [@mstemm](https://github.com/mstemm)
-* update(userspace/falco): enable using zlib with webserver [[#2125](https://github.com/falcosecurity/falco/pull/2125)] - [@jasondellaluce](https://github.com/jasondellaluce)
-* update(falco): add container-gvisor and kubernetes-gvisor print options [[#2288](https://github.com/falcosecurity/falco/pull/2288)] - [@LucaGuerra](https://github.com/LucaGuerra)
-* cleanup: always use bundled libz and libelf in BUNDLED_DEPS mode. [[#2277](https://github.com/falcosecurity/falco/pull/2277)] - [@FedeDP](https://github.com/FedeDP)
-* update: updated libs and driver to version dd443b67c6b04464cb8ee2771af8ada8777e7fac [[#2277](https://github.com/falcosecurity/falco/pull/2277)] - [@FedeDP](https://github.com/FedeDP)
-* update(falco.yaml): `open_params` under plugins configuration is now trimmed from surrounding whitespace [[#2267](https://github.com/falcosecurity/falco/pull/2267)] - [@yardenshoham](https://github.com/yardenshoham)
-
-
-### Bug Fixes
-
-* fix(engine): Avoid crash related to caching syscall source when the falco engine uses multiple sources at the same time. [[#2272](https://github.com/falcosecurity/falco/pull/2272)] - [@mstemm](https://github.com/mstemm)
-* fix(scripts): use falco-driver-loader only into install scripts [[#2391](https://github.com/falcosecurity/falco/pull/2391)] - [@Andreagit97](https://github.com/Andreagit97)
-* fix(userspace/falco): fix grpc server shutdown [[#2350](https://github.com/falcosecurity/falco/pull/2350)] - [@FedeDP](https://github.com/FedeDP)
-* fix(docker/falco): trust latest GPG key [[#2365](https://github.com/falcosecurity/falco/pull/2365)] - [@jasondellaluce](https://github.com/jasondellaluce)
-* fix(userspace/engine): improve rule loading validation results [[#2344](https://github.com/falcosecurity/falco/pull/2344)] - [@jasondellaluce](https://github.com/jasondellaluce)
-* fix: graceful error handling for macros/lists reference loops [[#2311](https://github.com/falcosecurity/falco/pull/2311)] - [@jasondellaluce](https://github.com/jasondellaluce)
-
-
-### Rule Changes
-
-* rules(tagging): enhanced rules tagging for inventory / threat modeling [[#2167](https://github.com/falcosecurity/falco/pull/2167)] - [@incertum](https://github.com/incertum)
-* rule(Outbound Connection to C2 Server): Update the "Outbound connection to C2 server" rule to match both FQDN and IP addresses. Prior to this change, the rule only matched IP addresses and not FQDN. [[#2241](https://github.com/falcosecurity/falco/pull/2241)] - [@Nicolas-Peiffer](https://github.com/Nicolas-Peiffer)
-* rule(Execution from /dev/shm): new rule to detect execution from /dev/shm [[#2225](https://github.com/falcosecurity/falco/pull/2225)] - [@AlbertoPellitteri](https://github.com/AlbertoPellitteri)
-* rule(Find AWS Credentials): new rule to detect executions looking for AWS credentials [[#2224](https://github.com/falcosecurity/falco/pull/2224)] - [@AlbertoPellitteri](https://github.com/AlbertoPellitteri)
-* rule(Linux Kernel Module Injection Detected): improve insmod detection within container using CAP_SYS_MODULE [[#2305](https://github.com/falcosecurity/falco/pull/2305)] - [@loresuso](https://github.com/loresuso)
-* rule(Read sensitive file untrusted): let salt-call read sensitive files [[#2291](https://github.com/falcosecurity/falco/pull/2291)] - [@vin01](https://github.com/vin01)
-* rule(macro: rpm_procs): let salt-call write to rpm database [[#2291](https://github.com/falcosecurity/falco/pull/2291)] - [@vin01](https://github.com/vin01)
-
-
-### Non user-facing changes
-
-* fix(ci): fix rpm sign job dependencies [[#2324](https://github.com/falcosecurity/falco/pull/2324)] - [@cappellinsamuele](https://github.com/cappellinsamuele)
-* chore(userspace): add `njson` lib as a dependency for `falco_engine` [[#2316](https://github.com/falcosecurity/falco/pull/2316)] - [@Andreagit97](https://github.com/Andreagit97)
-* fix(scripts): force rpm postinstall script to always show dialog, even on upgrade [[#2405](https://github.com/falcosecurity/falco/pull/2405)] - [@FedeDP](https://github.com/FedeDP)
-* fix(scripts): fixed falcoctl config install dir. [[#2399](https://github.com/falcosecurity/falco/pull/2399)] - [@FedeDP](https://github.com/FedeDP)
-* fix(scripts): make /usr writable [[#2398](https://github.com/falcosecurity/falco/pull/2398)] - [@therealbobo](https://github.com/therealbobo)
-* fix(scripts): driver loader insmod [[#2388](https://github.com/falcosecurity/falco/pull/2388)] - [@FedeDP](https://github.com/FedeDP)
-* update(systemd): solve some issues with systemd unit [[#2385](https://github.com/falcosecurity/falco/pull/2385)] - [@Andreagit97](https://github.com/Andreagit97)
-* build(cmake): upgrade falcoctl to v0.3.0-rc6 [[#2383](https://github.com/falcosecurity/falco/pull/2383)] - [@leogr](https://github.com/leogr)
-* docs(.github): rules are no longer in this repo [[#2382](https://github.com/falcosecurity/falco/pull/2382)] - [@leogr](https://github.com/leogr)
-* update(CI): mitigate frequent failure in CircleCI jobs [[#2375](https://github.com/falcosecurity/falco/pull/2375)] - [@Andreagit97](https://github.com/Andreagit97)
-* fix(userspace): use the right path for the `cpus_for_each_syscall_buffer` config [[#2378](https://github.com/falcosecurity/falco/pull/2378)] - [@Andreagit97](https://github.com/Andreagit97)
-* fix(scripts): fixed incorrect bash var expansion [[#2367](https://github.com/falcosecurity/falco/pull/2367)] - [@therealbobo](https://github.com/therealbobo)
-* update(CI): upgrade toolchain in modern falco builder dockerfile [[#2337](https://github.com/falcosecurity/falco/pull/2337)] - [@Andreagit97](https://github.com/Andreagit97)
-* cleanup(ci): move static analysis job from circle CI to GHA [[#2332](https://github.com/falcosecurity/falco/pull/2332)] - [@Andreagit97](https://github.com/Andreagit97)
-* update(falco): update cpp-httplib to 0.11.3 [[#2327](https://github.com/falcosecurity/falco/pull/2327)] - [@LucaGuerra](https://github.com/LucaGuerra)
-* update(script): makes user able to pass custom option to driver-loade… [[#1901](https://github.com/falcosecurity/falco/pull/1901)] - [@andreabonanno](https://github.com/andreabonanno)
-* cleanup(ci): remove some unused jobs and remove some `falco-builder` reference where possible [[#2322](https://github.com/falcosecurity/falco/pull/2322)] - [@Andreagit97](https://github.com/Andreagit97)
-* docs(proposal): new artifacts distribution proposal [[#2304](https://github.com/falcosecurity/falco/pull/2304)] - [@leogr](https://github.com/leogr)
-* fix(cmake): properly fetch dev version by appending latest Falco tag, delta between master and tag, and hash [[#2292](https://github.com/falcosecurity/falco/pull/2292)] - [@FedeDP](https://github.com/FedeDP)
-* chore(deps): Bump certifi from 2020.4.5.1 to 2022.12.7 in /test [[#2313](https://github.com/falcosecurity/falco/pull/2313)] - [@dependabot[bot]](https://github.com/apps/dependabot)
-* chore: remove string view lite [[#2307](https://github.com/falcosecurity/falco/pull/2307)] - [@leogr](https://github.com/leogr)
-* new(CHANGELOG): add entry for 0.33.1 (in master branch this time) [[#2303](https://github.com/falcosecurity/falco/pull/2303)] - [@LucaGuerra](https://github.com/LucaGuerra)
-* update(docs): add overview and versioning sections to falco release.md [[#2205](https://github.com/falcosecurity/falco/pull/2205)] - [@incertum](https://github.com/incertum)
-* Add Xenit AB to adopters [[#2285](https://github.com/falcosecurity/falco/pull/2285)] - [@NissesSenap](https://github.com/NissesSenap)
-* fix(userspace/falco): verify engine fields only for syscalls [[#2281](https://github.com/falcosecurity/falco/pull/2281)] - [@jasondellaluce](https://github.com/jasondellaluce)
-* fix(output): do not print syscall_buffer_size when gvisor is enabled [[#2283](https://github.com/falcosecurity/falco/pull/2283)] - [@alacuku](https://github.com/alacuku)
-* fix(engine): fix warning about redundant std::move [[#2286](https://github.com/falcosecurity/falco/pull/2286)] - [@LucaGuerra](https://github.com/LucaGuerra)
-* fix(scripts): force falco-driver-loader script to try to compile the driver anyway even on unsupported platforms [[#2219](https://github.com/falcosecurity/falco/pull/2219)] - [@FedeDP](https://github.com/FedeDP)
-* fix(ci): fixed version bucket for release jobs. [[#2266](https://github.com/falcosecurity/falco/pull/2266)] - [@FedeDP](https://github.com/FedeDP)
-
 ## v0.33.1

 Released on 2022-11-24
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,7 +18,6 @@ option(USE_BUNDLED_DEPS "Bundle hard to find dependencies into the Falco binary"
 option(BUILD_WARNINGS_AS_ERRORS "Enable building with -Wextra -Werror flags" OFF)
 option(MINIMAL_BUILD "Build a minimal version of Falco, containing only the engine and basic input/output (EXPERIMENTAL)" OFF)
 option(MUSL_OPTIMIZED_BUILD "Enable if you want a musl optimized build" OFF)
-option(BUILD_FALCO_UNIT_TESTS "Build falco unit tests" OFF)

 # gVisor is currently only supported on Linux x86_64
 if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64" AND CMAKE_SYSTEM_NAME MATCHES "Linux" AND NOT MINIMAL_BUILD)
@@ -44,8 +43,6 @@ if (${EP_UPDATE_DISCONNECTED})
    PROPERTY EP_UPDATE_DISCONNECTED TRUE)
 endif()

-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_EXTENSIONS OFF)

 # Elapsed time
 # set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CMAKE_COMMAND} -E time") # TODO(fntlnz, leodido): add a flag to enable this
@@ -110,7 +107,7 @@ if(BUILD_WARNINGS_AS_ERRORS)
 endif()

 set(CMAKE_C_FLAGS "${CMAKE_COMMON_FLAGS}")
-set(CMAKE_CXX_FLAGS "-std=c++17 ${CMAKE_COMMON_FLAGS} -Wno-class-memaccess")
+set(CMAKE_CXX_FLAGS "--std=c++0x ${CMAKE_COMMON_FLAGS} -Wno-class-memaccess")

 set(CMAKE_C_FLAGS_DEBUG "${FALCO_EXTRA_DEBUG_FLAGS}")
 set(CMAKE_CXX_FLAGS_DEBUG "${FALCO_EXTRA_DEBUG_FLAGS}")
@@ -151,7 +148,16 @@ include(falcosecurity-libs)
 include(jq)

 # nlohmann-json
-include(njson)
+set(NJSON_SRC "${PROJECT_BINARY_DIR}/njson-prefix/src/njson")
+message(STATUS "Using bundled nlohmann-json in '${NJSON_SRC}'")
+set(NJSON_INCLUDE "${NJSON_SRC}/single_include")
+ExternalProject_Add(
+  njson
+  URL "https://github.com/nlohmann/json/archive/v3.3.0.tar.gz"
+  URL_HASH "SHA256=2fd1d207b4669a7843296c41d3b6ac5b23d00dec48dba507ba051d14564aa801"
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND ""
+  INSTALL_COMMAND "")

 # b64
 include(b64)
@@ -195,7 +201,7 @@ if(NOT MINIMAL_BUILD)
 endif()

 # Rules
-include(rules)
+add_subdirectory(rules)

 # Dockerfiles
 add_subdirectory(docker)
@@ -216,16 +222,11 @@ set(FALCO_BIN_DIR bin)
 add_subdirectory(scripts)
 add_subdirectory(userspace/engine)
 add_subdirectory(userspace/falco)
+add_subdirectory(tests)

 if(NOT MUSL_OPTIMIZED_BUILD)
  include(plugins)
 endif()

-include(falcoctl)
-
 # Packages configuration
 include(CPackConfig)
-
-if(BUILD_FALCO_UNIT_TESTS)
-  add_subdirectory(unit_tests)
-endif()
--- a/README.md
+++ b/README.md
@@ -80,8 +80,6 @@ For example, Falco can easily detect incidents including but not limited to:
 - A standard system binary, such as `ls`, is making an outbound network connection.
 - A privileged pod is started in a Kubernetes cluster.

-The official Falco rules are maintained and released in [falcosecurity/rules](https://github.com/falcosecurity/rules/). That repository also contains the Falco rules inventory [document](https://github.com/falcosecurity/rules/blob/main/rules_inventory/rules_overview.md), which provides additional details around the default rules Falco ships with.
-
 ## Installing Falco

 If you would like to run Falco in **production** please adhere to the [official installation guide](https://falco.org/docs/getting-started/installation/).
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -21,17 +21,15 @@ Finally, the release process follows a transparent process described in more det

 ### Falco Binaries, Rules and Sources Artifacts - Quick Links

-The Falco project publishes all sources and the Falco userspace binaries as GitHub releases.
+The Falco project publishes all sources and the Falco userspace binaries as GitHub releases. Rules are also released in the GitHub tree Falco release tag.

 - [Falco Releases](https://github.com/falcosecurity/falco/releases)
    - `tgz`, `rpm` and `deb` Falco binary packages (contains sources, including driver sources, Falco rules as well as k8saudit and cloudtrail plugins)
    - `tgz`, `zip` source code
 - [Libs Releases](https://github.com/falcosecurity/libs/releases)
    - `tgz`, `zip` source code
- [Driver Releases](https://github.com/falcosecurity/libs/releases), marked with `+driver` [build metadata](https://semver.org/). 
-    - `tgz`, `zip` source code
- [Falco Rules Releases](https://github.com/falcosecurity/rules/releases)
-    - `tgz`, `zip` source code, each ruleset is tagged separately in a mono-repo fashion, see the [rules release guidelines](https://github.com/falcosecurity/rules/blob/main/RELEASE.md)
+- Falco Rules (GitHub tree approach)
+    - RELEASE="x.y.z", `https://github.com/falcosecurity/falco/tree/${RELEASE}/rules`


 Alternatively Falco binaries or plugins can be downloaded from the Falco Artifacts repo.
@@ -67,9 +65,9 @@ At a high level each Falco release needs to follow a pre-determined sequencing o

 - [1 - 3] `libs` (+ `driver`) and `plugins` components releases
 - [4] Falco driver pre-compiled object files push to Falco's Artifacts repo
- [5] Falco userspace binary release
+- [5] Falco userspace binary + rules release

-Finally, on the proposed due date the assignees for the upcoming release proceed with the processes described below.  
+Finally, on the proposed due date the assignees for the upcoming release proceed with the processes described below.

 ## Pre-Release Checklist

@@ -87,19 +85,7 @@ Prior to cutting a release the following preparatory steps should take 5 minutes

 - Move the [tasks not completed](https://github.com/falcosecurity/falco/pulls?q=is%3Apr+is%3Aopen) to a new minor milestone

-
-### 3. Release branch
-
-Assuming we are releasing a non-patch version (like: Falco 0.34.0), a new release branch needs to be created.  
-Its naming will be `release/M.m.x`; for example: `release/0.34.x`.  
-The same branch will then be used for any eventual cherry pick for patch releases.  
-
-For patch releases, instead, the `release/M.m.x` branch should already be in place; no more steps are needed.  
-Double check that any PR that should be part of the tag has been cherry-picked from master!
-
-### 4. Release PR
-
-The release PR is meant to be made against the respective `release/M.m.x` branch, **then cherry-picked on master**.  
+### 3. Release PR

 - Double-check if any hard-coded version number is present in the code, it should be not present anywhere:
    - If any, manually correct it then open an issue to automate version number bumping later
@@ -110,54 +96,50 @@ The release PR is meant to be made against the respective `release/M.m.x` branch
 - Add the latest changes on top the previous `CHANGELOG.md`
 - Submit a PR with the above modifications
 - Await PR approval
- Close the completed milestone as soon as the PR is merged into the release branch
- Cherry pick the PR on master too
-
-## Publishing Pre-Releases (RCs and tagged development versions)
-
-Core maintainers and/or the release manager can decide to publish pre-releases at any time before the final release
-is live for development and testing purposes.
-
-The prerelease tag must be formatted as `M.m.p-r`where `r` is the prerelease version information (e.g. `0.35.0-rc1`.)
-
-To do so:
-
- [Draft a new release](https://github.com/falcosecurity/falco/releases/new)
- Use `M.m.p-r` both as tag version and release title.
- Check the "Set as a pre-release" checkbox and make sure "Set as the latest release" is unchecked
- It is recommended to add a brief description so that other contributors will understand the reason why the prerelease is published
- Publish the prerelease!
- The release pipeline will start automatically. Packages will be uploaded to the `-dev` bucket and container images will be tagged with the specified tag.
-
-In order to check the status of the release pipeline click on the [GitHub Actions tab](https://github.com/falcosecurity/falco/actions?query=event%3Arelease) in the Falco repository and filter by release.
+- Close the completed milestone as soon as the PR is merged

 ## Release

-Assume `M.m.p` is the new version.
+Now assume `x.y.z` is the new version.

-### 1. Create the release with GitHub
+### 1. Create a tag
+
+- Once the release PR has got merged, and the CI has done its job on the master, git tag the new release
+
+    ```
+    git pull
+    git checkout master
+    git tag x.y.z
+    git push origin x.y.z
+    ```
+
+> **N.B.**: do NOT use an annotated tag. For reference https://git-scm.com/book/en/v2/Git-Basics-Tagging
+
+- Wait for the CI to complete
+
+### 2. Update the GitHub release

 - [Draft a new release](https://github.com/falcosecurity/falco/releases/new)
- Use `M.m.p` both as tag version and release title
+- Use `x.y.z` both as tag version and release title
 - Use the following template to fill the release description:
    ```
-    <!-- Substitute M.m.p with the current release version -->
+    <!-- Substitute x.y.z with the current release version -->

    | Packages | Download                                                                                                                                               |
    | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
-    | rpm-x86_64      | [![rpm](https://img.shields.io/badge/Falco-M.m.p-%2300aec7?style=flat-square)](https://download.falco.org/packages/rpm/falco-M.m.p-x86_64.rpm)        |
-    | deb-x86_64      | [![deb](https://img.shields.io/badge/Falco-M.m.p-%2300aec7?style=flat-square)](https://download.falco.org/packages/deb/stable/falco-M.m.p-x86_64.deb) |
-    | tgz-x86_64      | [![tgz](https://img.shields.io/badge/Falco-M.m.p-%2300aec7?style=flat-square)](https://download.falco.org/packages/bin/x86_64/falco-M.m.p-x86_64.tar.gz) |
-    | rpm-aarch64      | [![rpm](https://img.shields.io/badge/Falco-M.m.p-%2300aec7?style=flat-square)](https://download.falco.org/packages/rpm/falco-M.m.p-aarch64.rpm)        |
-    | deb-aarch64      | [![deb](https://img.shields.io/badge/Falco-M.m.p-%2300aec7?style=flat-square)](https://download.falco.org/packages/deb/stable/falco-M.m.p-aarch64.deb) |
-    | tgz-aarch64      | [![tgz](https://img.shields.io/badge/Falco-M.m.p-%2300aec7?style=flat-square)](https://download.falco.org/packages/bin/aarch64/falco-M.m.p-aarch64.tar.gz) |
+    | rpm-x86_64      | [![rpm](https://img.shields.io/badge/Falco-x.y.z-%2300aec7?style=flat-square)](https://download.falco.org/packages/rpm/falco-x.y.z-x86_64.rpm)        |
+    | deb-x86_64      | [![deb](https://img.shields.io/badge/Falco-x.y.z-%2300aec7?style=flat-square)](https://download.falco.org/packages/deb/stable/falco-x.y.z-x86_64.deb) |
+    | tgz-x86_64      | [![tgz](https://img.shields.io/badge/Falco-x.y.z-%2300aec7?style=flat-square)](https://download.falco.org/packages/bin/x86_64/falco-x.y.z-x86_64.tar.gz) |
+    | rpm-aarch64      | [![rpm](https://img.shields.io/badge/Falco-x.y.z-%2300aec7?style=flat-square)](https://download.falco.org/packages/rpm/falco-x.y.z-aarch64.rpm)        |
+    | deb-aarch64      | [![deb](https://img.shields.io/badge/Falco-x.y.z-%2300aec7?style=flat-square)](https://download.falco.org/packages/deb/stable/falco-x.y.z-aarch64.deb) |
+    | tgz-aarch64      | [![tgz](https://img.shields.io/badge/Falco-x.y.z-%2300aec7?style=flat-square)](https://download.falco.org/packages/bin/aarch64/falco-x.y.z-aarch64.tar.gz) |

    | Images                                                                      |
    | --------------------------------------------------------------------------- |
-    | `docker pull docker.io/falcosecurity/falco:M.m.p`                           |
-    | `docker pull public.ecr.aws/falcosecurity/falco:M.m.p`                      |
-    | `docker pull docker.io/falcosecurity/falco-driver-loader:M.m.p`             |
-    | `docker pull docker.io/falcosecurity/falco-no-driver:M.m.p`                 |
+    | `docker pull docker.io/falcosecurity/falco:x.y.z`                           |
+    | `docker pull public.ecr.aws/falcosecurity/falco:x.y.z`                      |
+    | `docker pull docker.io/falcosecurity/falco-driver-loader:x.y.z`             |
+    | `docker pull docker.io/falcosecurity/falco-no-driver:x.y.z`                 |

    <changelog>

@@ -179,17 +161,14 @@ Assume `M.m.p` is the new version.
    ```

 - Finally, publish the release!
- The release pipeline will start automatically upon publication and all packages and container images will be uploaded to the stable repositories.

-In order to check the status of the release pipeline click on the [GitHub Actions tab](https://github.com/falcosecurity/falco/actions?query=event%3Arelease) in the Falco repository and filter by release.
-
-### 2. Update the meeting notes
+### 3. Update the meeting notes

 For each release we archive the meeting notes in git for historical purposes.

 - The notes from the Falco meetings can be [found here](https://hackmd.io/3qYPnZPUQLGKCzR14va_qg).
    - Note: There may be other notes from working groups that can optionally be added as well as needed.
- - Add the entire content of the document to a new file in [github.com/falcosecurity/community/tree/master/meeting-notes](https://github.com/falcosecurity/community/tree/master/meeting-notes) as a new file labeled `release-M.m.p.md`
+ - Add the entire content of the document to a new file in [github.com/falcosecurity/community/tree/master/meeting-notes](https://github.com/falcosecurity/community/tree/master/meeting-notes) as a new file labeled `release-x.y.z.md`
 - Open up a pull request with the new change.


@@ -210,7 +189,7 @@ This section provides more details around the versioning of all components that

 ### Falco repo (this repo)
 - Falco version is a git tag (`x.y.z`), see [Procedures](#procedures) section. Note that the Falco version is a sem-ver-like schema, but not fully compatible with sem-ver.
- [FALCO_ENGINE_VERSION](https://github.com/falcosecurity/falco/blob/master/userspace/engine/falco_engine_version.h) is not sem-ver and must be bumped either when a backward incompatible change has been introduced to the rules files syntax or `falco --list -N | sha256sum` has changed. Breaking changes introduced in the Falco engine are not necessarily tied to the drivers or libs versions. The primary idea behind the hash is that when new filter / display fields (see currently supported [Falco fields](https://falco.org/docs/rules/supported-fields/)) are introduced a version bump indicates that this field was not available in previous engine versions. See the [rules release guidelines](https://github.com/falcosecurity/rules/blob/main/RELEASE.md#versioning-a-ruleset) to understand how this affects the versioning of Falco rules.
+- [FALCO_ENGINE_VERSION](https://github.com/falcosecurity/falco/blob/master/userspace/engine/falco_engine_version.h) is not sem-ver and must be bumped either when a backward incompatible change has been introduced to the rules files syntax or `falco --list -N | sha256sum` has changed. Breaking changes introduced in the Falco engine are not necessarily tied to the drivers or libs versions. The primary idea behind the hash is that when new filter / display fields (see currently supported [Falco fields](https://falco.org/docs/rules/supported-fields/)) are introduced a version bump indicates that this field was not available in previous engine versions. In case a new Falco rule uses new fields, the [Falco rules](https://github.com/falcosecurity/falco/blob/master/rules/falco_rules.yaml) file needs to bump this version as well via setting `required_engine_version` to the new version.
 - During development and release preparation, libs and driver reference commits are often bumped in Falco's cmake setup ([falcosecurity-libs cmake](https://github.com/falcosecurity/falco/blob/master/cmake/modules/falcosecurity-libs.cmake#L30) and [driver cmake](https://github.com/falcosecurity/falco/blob/master/cmake/modules/driver.cmake#L29)) in order to merge new Falco features. In practice they are mostly bumped at the same time referencing the same `libs` commit. However, for the official Falco build `FALCOSECURITY_LIBS_VERSION` flag that references the stable Libs version is used (read below).
 - Similarly, Falco plugins versions are bumped in Falco's cmake setup ([plugins cmake](https://github.com/falcosecurity/falco/blob/master/cmake/modules/plugins.cmake)) and those versions are the ones used for the Falco release.
 - At release time Plugin, Libs and Driver versions are compatible with Falco.
@@ -221,7 +200,6 @@ This section provides more details around the versioning of all components that
 Falco version: x.y.z (sem-ver like)
 Libs version:  x.y.z (sem-ver like)
 Plugin API:    x.y.z (sem-ver like)
-Engine:        x
 Driver:
  API version:    x.y.z (sem-ver)
  Schema version: x.y.z (sem-ver)
@@ -231,15 +209,10 @@ Driver:

 ### Libs repo
 - Libs version is a git tag (`x.y.z`) and when building Falco the libs version is set via the `FALCOSECURITY_LIBS_VERSION` flag (see above).
- Driver version itself is not directly tied to the Falco binary as opposed to the libs version being part of the source code used to compile Falco's userspace binary. This is because of the strict separation between userspace and kernel space artifacts, so things become a bit more interesting here. This is why the concept of a `Default driver` has been introduced to still implicitly declare the compatible driver versions. For example, if the default driver version is `2.0.0+driver`, Falco works with all driver versions >= 2.0.0 and < 3.0.0. This is a consequence of how the driver version is constructed starting from the `Driver API version` and `Driver Schema version`. Driver API and Schema versions are explained in the respective [libs driver doc](https://github.com/falcosecurity/libs/blob/master/driver/README.VERSION.md) -> Falco's `driver-loader` will always fetch the default driver, therefore a Falco release is always "shipped" with the driver version corresponding to the default driver.
+- Driver version in and of itself is not directly tied to the Falco binary as opposed to the libs version being part of the source code used to compile Falco's userspace binary. This is because of the strict separation between userspace and kernel space artifacts, so things become a bit more interesting here. This is why the concept of a `Default driver` has been introduced to still implicitly declare the compatible driver versions. For example, if the default driver version is `2.0.0+driver`, Falco works with all driver versions >= 2.0.0 and < 3.0.0. This is a consequence of how the driver version is constructed starting from the `Driver API version` and `Driver Schema version`. Driver API and Schema versions are explained in the respective [libs driver doc](https://github.com/falcosecurity/libs/blob/master/driver/README.VERSION.md) -> Falco's `driver-loader` will always fetch the default driver, therefore a Falco release is always "shipped" with the driver version corresponding to the default driver.
 - See [libs release doc](https://github.com/falcosecurity/libs/blob/master/release.md) for more information.

 ### Plugins repo

 - Plugins version is a git tag (`x.y.z`)
 - See [plugins release doc](https://github.com/falcosecurity/plugins/blob/master/release.md) for more information.
-
-### Rules repo
- Rulesets are versioned individually through git tags
- See [rules release doc](https://github.com/falcosecurity/rules/blob/main/RELEASE.md) for more information.
- See [plugins release doc](https://github.com/falcosecurity/plugins/blob/master/release.md) for more information about plugins rulesets.
--- a/audits/SECURITY_AUDIT_2023_01_23-01-1097-LIV.pdf
+++ b/audits/SECURITY_AUDIT_2023_01_23-01-1097-LIV.pdf
--- a/brand/README.md
+++ b/brand/README.md
@@ -3,9 +3,7 @@

 # Falco Branding Guidelines

-Falco is an open source security project whose brand and identity are governed by the [Cloud Native Computing Foundation](https://www.linuxfoundation.org/legal/trademark-usage).
-
-This document describes the official branding guidelines of The Falco Project. Please see the [Falco Branding](https://falco.org/community/falco-brand/) page on our website for further details.
+This document describes The Falco Project's branding guidelines, language, and message.

 Content in this document can be used to publicly share about Falco.

@@ -84,7 +82,7 @@ Examples of malicious behavior include:

 Falco is capable of [consuming the Kubernetes audit logs](https://kubernetes.io/docs/tasks/debug-application-cluster/falco/#use-falco-to-collect-audit-events).
 By adding Kubernetes application context, and Kubernetes audit logs teams can understand who did what.
-
+                                 
 ### Writing about Falco

 ##### Yes
@@ -124,6 +122,7 @@ Falco does not prevent unwanted behavior.
 Falco however alerts when unusual behavior occurs.
 This is commonly referred to as **detection** or **forensics**.

+
 ---

 # Glossary 
--- a/cmake/cpack/CMakeCPackOptions.cmake
+++ b/cmake/cpack/CMakeCPackOptions.cmake
@@ -1,11 +1,13 @@
-if(CPACK_GENERATOR MATCHES "DEB" OR CPACK_GENERATOR MATCHES "RPM")
+if(CPACK_GENERATOR MATCHES "DEB")
 	list(APPEND CPACK_INSTALL_COMMANDS "mkdir -p _CPack_Packages/${CPACK_TOPLEVEL_TAG}/${CPACK_GENERATOR}/${CPACK_PACKAGE_FILE_NAME}/usr/lib/systemd/system")
-	list(APPEND CPACK_INSTALL_COMMANDS "cp scripts/systemd/falco-kmod-inject.service _CPack_Packages/${CPACK_TOPLEVEL_TAG}/${CPACK_GENERATOR}/${CPACK_PACKAGE_FILE_NAME}/usr/lib/systemd/system")
-	list(APPEND CPACK_INSTALL_COMMANDS "cp scripts/systemd/falco-kmod.service _CPack_Packages/${CPACK_TOPLEVEL_TAG}/${CPACK_GENERATOR}/${CPACK_PACKAGE_FILE_NAME}/usr/lib/systemd/system")
-	list(APPEND CPACK_INSTALL_COMMANDS "cp scripts/systemd/falco-bpf.service _CPack_Packages/${CPACK_TOPLEVEL_TAG}/${CPACK_GENERATOR}/${CPACK_PACKAGE_FILE_NAME}/usr/lib/systemd/system")
-	list(APPEND CPACK_INSTALL_COMMANDS "cp scripts/systemd/falco-modern-bpf.service _CPack_Packages/${CPACK_TOPLEVEL_TAG}/${CPACK_GENERATOR}/${CPACK_PACKAGE_FILE_NAME}/usr/lib/systemd/system")
-	list(APPEND CPACK_INSTALL_COMMANDS "cp scripts/systemd/falco-custom.service _CPack_Packages/${CPACK_TOPLEVEL_TAG}/${CPACK_GENERATOR}/${CPACK_PACKAGE_FILE_NAME}/usr/lib/systemd/system")
-	list(APPEND CPACK_INSTALL_COMMANDS "cp scripts/systemd/falcoctl-artifact-follow.service _CPack_Packages/${CPACK_TOPLEVEL_TAG}/${CPACK_GENERATOR}/${CPACK_PACKAGE_FILE_NAME}/usr/lib/systemd/system")
+	list(APPEND CPACK_INSTALL_COMMANDS "cp scripts/debian/falco.service _CPack_Packages/${CPACK_TOPLEVEL_TAG}/${CPACK_GENERATOR}/${CPACK_PACKAGE_FILE_NAME}/usr/lib/systemd/system")
+	list(APPEND CPACK_INSTALL_COMMANDS "cp scripts/debian/falco_inject_kmod.service _CPack_Packages/${CPACK_TOPLEVEL_TAG}/${CPACK_GENERATOR}/${CPACK_PACKAGE_FILE_NAME}/usr/lib/systemd/system")
+endif()
+
+if(CPACK_GENERATOR MATCHES "RPM")
+	list(APPEND CPACK_INSTALL_COMMANDS "mkdir -p _CPack_Packages/${CPACK_TOPLEVEL_TAG}/${CPACK_GENERATOR}/${CPACK_PACKAGE_FILE_NAME}/usr/lib/systemd/system")
+	list(APPEND CPACK_INSTALL_COMMANDS "cp scripts/rpm/falco.service _CPack_Packages/${CPACK_TOPLEVEL_TAG}/${CPACK_GENERATOR}/${CPACK_PACKAGE_FILE_NAME}/usr/lib/systemd/system")
+	list(APPEND CPACK_INSTALL_COMMANDS "cp scripts/rpm/falco_inject_kmod.service _CPack_Packages/${CPACK_TOPLEVEL_TAG}/${CPACK_GENERATOR}/${CPACK_PACKAGE_FILE_NAME}/usr/lib/systemd/system")
 endif()

 if(CPACK_GENERATOR MATCHES "TGZ")
--- a/cmake/cpack/debian/conffiles
+++ b/cmake/cpack/debian/conffiles
@@ -1,3 +1,3 @@
 /etc/falco/falco.yaml
-/etc/falco/falcoctl.yaml
+/etc/falco/rules.available/application_rules.yaml
 /etc/falco/falco_rules.local.yaml
--- a/cmake/modules/Catch.cmake
+++ b/cmake/modules/Catch.cmake
@@ -0,0 +1,159 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying file Copyright.txt or
+# https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+Catch
+-----
+
+This module defines a function to help use the Catch test framework.
+
+The :command:`catch_discover_tests` discovers tests by asking the compiled test
+executable to enumerate its tests.  This does not require CMake to be re-run
+when tests change.  However, it may not work in a cross-compiling environment,
+and setting test properties is less convenient.
+
+This command is intended to replace use of :command:`add_test` to register
+tests, and will create a separate CTest test for each Catch test case.  Note
+that this is in some cases less efficient, as common set-up and tear-down logic
+cannot be shared by multiple test cases executing in the same instance.
+However, it provides more fine-grained pass/fail information to CTest, which is
+usually considered as more beneficial.  By default, the CTest test name is the
+same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
+
+.. command:: catch_discover_tests
+
+  Automatically add tests with CTest by querying the compiled test executable
+  for available tests::
+
+    catch_discover_tests(target
+                         [TEST_SPEC arg1...]
+                         [EXTRA_ARGS arg1...]
+                         [WORKING_DIRECTORY dir]
+                         [TEST_PREFIX prefix]
+                         [TEST_SUFFIX suffix]
+                         [PROPERTIES name1 value1...]
+                         [TEST_LIST var]
+    )
+
+  ``catch_discover_tests`` sets up a post-build command on the test executable
+  that generates the list of tests by parsing the output from running the test
+  with the ``--list-test-names-only`` argument.  This ensures that the full
+  list of tests is obtained.  Since test discovery occurs at build time, it is
+  not necessary to re-run CMake when the list of tests changes.
+  However, it requires that :prop_tgt:`CROSSCOMPILING_EMULATOR` is properly set
+  in order to function in a cross-compiling environment.
+
+  Additionally, setting properties on tests is somewhat less convenient, since
+  the tests are not available at CMake time.  Additional test properties may be
+  assigned to the set of tests as a whole using the ``PROPERTIES`` option.  If
+  more fine-grained test control is needed, custom content may be provided
+  through an external CTest script using the :prop_dir:`TEST_INCLUDE_FILES`
+  directory property.  The set of discovered tests is made accessible to such a
+  script via the ``<target>_TESTS`` variable.
+
+  The options are:
+
+  ``target``
+    Specifies the Catch executable, which must be a known CMake executable
+    target.  CMake will substitute the location of the built executable when
+    running the test.
+
+  ``TEST_SPEC arg1...``
+    Specifies test cases, wildcarded test cases, tags and tag expressions to
+    pass to the Catch executable with the ``--list-test-names-only`` argument.
+
+  ``EXTRA_ARGS arg1...``
+    Any extra arguments to pass on the command line to each test case.
+
+  ``WORKING_DIRECTORY dir``
+    Specifies the directory in which to run the discovered test cases.  If this
+    option is not provided, the current binary directory is used.
+
+  ``TEST_PREFIX prefix``
+    Specifies a ``prefix`` to be prepended to the name of each discovered test
+    case.  This can be useful when the same test executable is being used in
+    multiple calls to ``catch_discover_tests()`` but with different
+    ``TEST_SPEC`` or ``EXTRA_ARGS``.
+
+  ``TEST_SUFFIX suffix``
+    Similar to ``TEST_PREFIX`` except the ``suffix`` is appended to the name of
+    every discovered test case.  Both ``TEST_PREFIX`` and ``TEST_SUFFIX`` may
+    be specified.
+
+  ``PROPERTIES name1 value1...``
+    Specifies additional properties to be set on all tests discovered by this
+    invocation of ``catch_discover_tests``.
+
+  ``TEST_LIST var``
+    Make the list of tests available in the variable ``var``, rather than the
+    default ``<target>_TESTS``.  This can be useful when the same test
+    executable is being used in multiple calls to ``catch_discover_tests()``.
+    Note that this variable is only available in CTest.
+
+#]=======================================================================]
+
+# ------------------------------------------------------------------------------
+function(catch_discover_tests TARGET)
+  cmake_parse_arguments("" "" "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST" "TEST_SPEC;EXTRA_ARGS;PROPERTIES"
+                        ${ARGN})
+
+  if(NOT _WORKING_DIRECTORY)
+    set(_WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
+  endif()
+  if(NOT _TEST_LIST)
+    set(_TEST_LIST ${TARGET}_TESTS)
+  endif()
+
+  # Generate a unique name based on the extra arguments
+  string(SHA1 args_hash "${_TEST_SPEC} ${_EXTRA_ARGS}")
+  string(SUBSTRING ${args_hash} 0 7 args_hash)
+
+  # Define rule to generate test list for aforementioned test executable
+  set(ctest_include_file "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_include-${args_hash}.cmake")
+  set(ctest_tests_file "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_tests-${args_hash}.cmake")
+  get_property(
+    crosscompiling_emulator
+    TARGET ${TARGET}
+    PROPERTY CROSSCOMPILING_EMULATOR)
+  add_custom_command(
+    TARGET ${TARGET}
+    POST_BUILD
+    BYPRODUCTS "${ctest_tests_file}"
+    COMMAND
+      "${CMAKE_COMMAND}" -D "TEST_TARGET=${TARGET}" -D "TEST_EXECUTABLE=$<TARGET_FILE:${TARGET}>" -D
+      "TEST_EXECUTOR=${crosscompiling_emulator}" -D "TEST_WORKING_DIR=${_WORKING_DIRECTORY}" -D
+      "TEST_SPEC=${_TEST_SPEC}" -D "TEST_EXTRA_ARGS=${_EXTRA_ARGS}" -D "TEST_PROPERTIES=${_PROPERTIES}" -D
+      "TEST_PREFIX=${_TEST_PREFIX}" -D "TEST_SUFFIX=${_TEST_SUFFIX}" -D "TEST_LIST=${_TEST_LIST}" -D
+      "CTEST_FILE=${ctest_tests_file}" -P "${_CATCH_DISCOVER_TESTS_SCRIPT}"
+    VERBATIM)
+
+  file(
+    WRITE "${ctest_include_file}"
+    "if(EXISTS \"${ctest_tests_file}\")\n" "  include(\"${ctest_tests_file}\")\n" "else()\n"
+    "  add_test(${TARGET}_NOT_BUILT-${args_hash} ${TARGET}_NOT_BUILT-${args_hash})\n" "endif()\n")
+
+  if(NOT ${CMAKE_VERSION} VERSION_LESS "3.10.0")
+    # Add discovered tests to directory TEST_INCLUDE_FILES
+    set_property(
+      DIRECTORY
+      APPEND
+      PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}")
+  else()
+    # Add discovered tests as directory TEST_INCLUDE_FILE if possible
+    get_property(
+      test_include_file_set
+      DIRECTORY
+      PROPERTY TEST_INCLUDE_FILE
+      SET)
+    if(NOT ${test_include_file_set})
+      set_property(DIRECTORY PROPERTY TEST_INCLUDE_FILE "${ctest_include_file}")
+    else()
+      message(FATAL_ERROR "Cannot set more than one TEST_INCLUDE_FILE")
+    endif()
+  endif()
+
+endfunction()
+
+# ######################################################################################################################
+
+set(_CATCH_DISCOVER_TESTS_SCRIPT ${CMAKE_CURRENT_LIST_DIR}/CatchAddTests.cmake)
--- a/cmake/modules/CatchAddTests.cmake
+++ b/cmake/modules/CatchAddTests.cmake
@@ -0,0 +1,61 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying file Copyright.txt or
+# https://cmake.org/licensing for details.
+
+set(prefix "${TEST_PREFIX}")
+set(suffix "${TEST_SUFFIX}")
+set(spec ${TEST_SPEC})
+set(extra_args ${TEST_EXTRA_ARGS})
+set(properties ${TEST_PROPERTIES})
+set(script)
+set(suite)
+set(tests)
+
+function(add_command NAME)
+  set(_args "")
+  foreach(_arg ${ARGN})
+    if(_arg MATCHES "[^-./:a-zA-Z0-9_]")
+      set(_args "${_args} [==[${_arg}]==]") # form a bracket_argument
+    else()
+      set(_args "${_args} ${_arg}")
+    endif()
+  endforeach()
+  set(script
+      "${script}${NAME}(${_args})\n"
+      PARENT_SCOPE)
+endfunction()
+
+# Run test executable to get list of available tests
+if(NOT EXISTS "${TEST_EXECUTABLE}")
+  message(FATAL_ERROR "Specified test executable '${TEST_EXECUTABLE}' does not exist")
+endif()
+execute_process(
+  COMMAND ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" ${spec} --list-test-names-only
+  OUTPUT_VARIABLE output
+  RESULT_VARIABLE result)
+# Catch --list-test-names-only reports the number of tests, so 0 is... surprising
+if(${result} EQUAL 0)
+  message(WARNING "Test executable '${TEST_EXECUTABLE}' contains no tests!\n")
+elseif(${result} LESS 0)
+  message(FATAL_ERROR "Error running test executable '${TEST_EXECUTABLE}':\n" "  Result: ${result}\n"
+                      "  Output: ${output}\n")
+endif()
+
+string(REPLACE "\n" ";" output "${output}")
+
+# Parse output
+foreach(line ${output})
+  set(test ${line})
+  # use escape commas to handle properly test cases with commands inside the name
+  string(REPLACE "," "\\," test_name ${test})
+  # ...and add to script
+  add_command(add_test "${prefix}${test}${suffix}" ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" "${test_name}" ${extra_args})
+  add_command(set_tests_properties "${prefix}${test}${suffix}" PROPERTIES WORKING_DIRECTORY "${TEST_WORKING_DIR}"
+              ${properties})
+  list(APPEND tests "${prefix}${test}${suffix}")
+endforeach()
+
+# Create a list of all discovered tests, which users may use to e.g. set properties on the tests
+add_command(set ${TEST_LIST} ${tests})
+
+# Write CTest script
+file(WRITE "${CTEST_FILE}" "${script}")
--- a/cmake/modules/DownloadCatch.cmake
+++ b/cmake/modules/DownloadCatch.cmake
@@ -0,0 +1,27 @@
+#
+# Copyright (C) 2020 The Falco Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+#
+include(ExternalProject)
+
+set(CATCH2_INCLUDE ${CMAKE_BINARY_DIR}/catch2-prefix/include)
+
+set(CATCH_EXTERNAL_URL URL https://github.com/catchorg/catch2/archive/v2.13.9.tar.gz URL_HASH
+                       SHA256=06dbc7620e3b96c2b69d57bf337028bf245a211b3cddb843835bfe258f427a52)
+
+ExternalProject_Add(
+  catch2
+  PREFIX ${CMAKE_BINARY_DIR}/catch2-prefix
+  ${CATCH_EXTERNAL_URL}
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND ""
+  INSTALL_COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/catch2-prefix/src/catch2/single_include/catch2/catch.hpp
+                  ${CATCH2_INCLUDE}/catch.hpp)
--- a/cmake/modules/DownloadFakeIt.cmake
+++ b/cmake/modules/DownloadFakeIt.cmake
@@ -0,0 +1,28 @@
+#
+# Copyright (C) 2020 The Falco Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+#
+include(ExternalProject)
+
+set(FAKEIT_INCLUDE ${CMAKE_BINARY_DIR}/fakeit-prefix/include)
+
+set(FAKEIT_EXTERNAL_URL URL https://github.com/eranpeer/fakeit/archive/2.0.9.tar.gz URL_HASH
+                        SHA256=dc4ee7b17a84c959019b92c20fce6dc9426e9e170b6edf84db6cb2e188520cd7)
+
+ExternalProject_Add(
+  fakeit-external
+  PREFIX ${CMAKE_BINARY_DIR}/fakeit-prefix
+  ${FAKEIT_EXTERNAL_URL}
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND ""
+  INSTALL_COMMAND
+    ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/fakeit-prefix/src/fakeit-external/single_header/catch/fakeit.hpp
+    ${FAKEIT_INCLUDE}/fakeit.hpp)
--- a/cmake/modules/FindMakedev.cmake
+++ b/cmake/modules/FindMakedev.cmake
@@ -0,0 +1,31 @@
+#
+# Copyright (C) 2020 The Falco Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+#
+
+# This module is used to understand where the makedev function is defined in the glibc in use. see 'man 3 makedev'
+# Usage: In your CMakeLists.txt include(FindMakedev)
+#
+# In your source code:
+#
+# #if HAVE_SYS_MKDEV_H #include <sys/mkdev.h> #endif #ifdef HAVE_SYS_SYSMACROS_H #include <sys/sysmacros.h> #endif
+#
+include(${CMAKE_ROOT}/Modules/CheckIncludeFile.cmake)
+
+check_include_file("sys/mkdev.h" HAVE_SYS_MKDEV_H)
+check_include_file("sys/sysmacros.h" HAVE_SYS_SYSMACROS_H)
+
+if(HAVE_SYS_MKDEV_H)
+  add_definitions(-DHAVE_SYS_MKDEV_H)
+endif()
+if(HAVE_SYS_SYSMACROS_H)
+  add_definitions(-DHAVE_SYS_SYSMACROS_H)
+endif()
--- a/cmake/modules/GetFalcoVersion.cmake
+++ b/cmake/modules/GetFalcoVersion.cmake
@@ -19,36 +19,29 @@ if(NOT FALCO_VERSION)
  # Try to obtain the exact git tag
  git_get_exact_tag(FALCO_TAG)
  if(NOT FALCO_TAG)
-      # Obtain the closest tag
-      git_describe(FALCO_VERSION "--always" "--tags" "--abbrev=7")
-      string(REGEX MATCH "^[0-9]+.[0-9]+.[0-9]+$" FALCO_TAG ${FALCO_VERSION})
-      if(FALCO_VERSION MATCHES "NOTFOUND$" OR FALCO_TAG STREQUAL "")
-        # Fetch current hash
-        get_git_head_revision(refspec FALCO_HASH)
-        if(NOT FALCO_HASH OR FALCO_HASH MATCHES "NOTFOUND$")
+      # Fetch current hash
+      get_git_head_revision(refspec FALCO_HASH)
+      if(NOT FALCO_HASH OR FALCO_HASH MATCHES "NOTFOUND$")
+        set(FALCO_VERSION "0.0.0")
+      else()
+        # Obtain the closest tag
+        git_get_latest_tag(FALCO_LATEST_TAG)
+        if(NOT FALCO_LATEST_TAG OR FALCO_LATEST_TAG MATCHES "NOTFOUND$")
          set(FALCO_VERSION "0.0.0")
        else()
-          # Obtain the closest tag
-          git_get_latest_tag(FALCO_LATEST_TAG)
-          if(NOT FALCO_LATEST_TAG OR FALCO_LATEST_TAG MATCHES "NOTFOUND$")
+          # Compute commit delta since tag
+          git_get_delta_from_tag(FALCO_DELTA ${FALCO_LATEST_TAG} ${FALCO_HASH})
+          if(NOT FALCO_DELTA OR FALCO_DELTA MATCHES "NOTFOUND$")
            set(FALCO_VERSION "0.0.0")
          else()
-            # Compute commit delta since tag
-            git_get_delta_from_tag(FALCO_DELTA ${FALCO_LATEST_TAG} ${FALCO_HASH})
-            if(NOT FALCO_DELTA OR FALCO_DELTA MATCHES "NOTFOUND$")
-              set(FALCO_VERSION "0.0.0")
-            else()
-              # Cut hash to 7 bytes
-              string(SUBSTRING ${FALCO_HASH} 0 7 FALCO_HASH)
-              # Format FALCO_VERSION to be semver with prerelease and build part
-              set(FALCO_VERSION
-                    "${FALCO_LATEST_TAG}-${FALCO_DELTA}+${FALCO_HASH}")
-            endif()
-          endif()
+            # Cut hash to 7 bytes
+            string(SUBSTRING ${FALCO_HASH} 0 7 FALCO_HASH)
+            # Format FALCO_VERSION to be semver with prerelease and build part
+            set(FALCO_VERSION
+                  "${FALCO_LATEST_TAG}-${FALCO_DELTA}+${FALCO_HASH}")
+           endif()
        endif()
      endif()
-      # Format FALCO_VERSION to be semver with prerelease and build part
-      string(REPLACE "-g" "+" FALCO_VERSION "${FALCO_VERSION}")
  else()
    # A tag has been found: use it as the Falco version
    set(FALCO_VERSION "${FALCO_TAG}")
--- a/cmake/modules/GetGitRevisionDescription.cmake
+++ b/cmake/modules/GetGitRevisionDescription.cmake
@@ -91,16 +91,15 @@ function(git_get_latest_tag _var)
    find_package(Git QUIET)
  endif()

-  # We use git describe --tags `git rev-list --exclude "*.*.*-*" --tags --max-count=1`
-  # Note how we eclude prereleases tags (the ones with "-alphaX")
+  # We use git describe --tags `git rev-list --tags --max-count=1`
  execute_process(COMMAND
          "${GIT_EXECUTABLE}"
          rev-list
-          --exclude "*.*.*-*"
          --tags
          --max-count=1
          WORKING_DIRECTORY
          "${CMAKE_CURRENT_SOURCE_DIR}"
+          COMMAND tail -n1
          RESULT_VARIABLE
          res
          OUTPUT_VARIABLE
--- a/cmake/modules/cpp-httplib.cmake
+++ b/cmake/modules/cpp-httplib.cmake
@@ -24,8 +24,8 @@ else()

 	ExternalProject_Add(cpp-httplib
 		PREFIX "${PROJECT_BINARY_DIR}/cpp-httplib-prefix"
-		URL "https://github.com/yhirose/cpp-httplib/archive/refs/tags/v0.11.3.tar.gz"
-		URL_HASH "SHA256=799b2daa0441d207f6cd1179ae3a34869722084a434da6614978be1682c1e12d"
+		URL "https://github.com/yhirose/cpp-httplib/archive/refs/tags/v0.10.4.tar.gz"
+		URL_HASH "SHA256=7719ff9f309c807dd8a574048764836b6a12bcb7d6ae9e129e7e4289cfdb4bd4"
 		CONFIGURE_COMMAND ""
 		BUILD_COMMAND ""
 		INSTALL_COMMAND "")	
--- a/cmake/modules/driver.cmake
+++ b/cmake/modules/driver.cmake
@@ -26,8 +26,8 @@ else()
  # In case you want to test against another driver version (or branch, or commit) just pass the variable -
  # ie., `cmake -DDRIVER_VERSION=dev ..`
  if(NOT DRIVER_VERSION)
-    set(DRIVER_VERSION "5.0.0+driver")
-    set(DRIVER_CHECKSUM "SHA256=c988ca7ac7d174f62d1bfbaaca49efd117f7b329f474d1b46b643635b2e35083")
+    set(DRIVER_VERSION "dd443b67c6b04464cb8ee2771af8ada8777e7fac")
+    set(DRIVER_CHECKSUM "SHA256=df373099d0f4cd4417a0103bb57f26c7412ffa86cde2bb2d579c6feba841626d")
  endif()

  # cd /path/to/build && cmake /path/to/source
--- a/cmake/modules/falcoctl.cmake
+++ b/cmake/modules/falcoctl.cmake
@@ -1,36 +0,0 @@
-#
-# Copyright (C) 2023 The Falco Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
-# the License. You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations under the License.
-#
-
-include(ExternalProject)
-
-string(TOLOWER ${CMAKE_HOST_SYSTEM_NAME} FALCOCTL_SYSTEM_NAME)
-
-set(FALCOCTL_VERSION "0.4.0")
-
-if(${CMAKE_HOST_SYSTEM_PROCESSOR} STREQUAL "x86_64")
-    set(FALCOCTL_SYSTEM_PROC_GO "amd64")
-    set(FALCOCTL_HASH "13c88e612efe955bc014918a7af30bae28dc5ba99b2962af57e36b1b87f527f9")
-else() # aarch64
-    set(FALCOCTL_SYSTEM_PROC_GO "arm64")
-    set(FALCOCTL_HASH "0f8898853e99a2cd1b4dd6b161e8545cf20ce0e3ce79cddc539f6002257d5de5")
-endif()
-
-ExternalProject_Add(
-        falcoctl
-        URL "https://github.com/falcosecurity/falcoctl/releases/download/v${FALCOCTL_VERSION}/falcoctl_${FALCOCTL_VERSION}_${FALCOCTL_SYSTEM_NAME}_${FALCOCTL_SYSTEM_PROC_GO}.tar.gz"
-        URL_HASH "SHA256=${FALCOCTL_HASH}"
-        CONFIGURE_COMMAND ""
-        BUILD_COMMAND ""
-        INSTALL_COMMAND "")
-
-install(PROGRAMS "${PROJECT_BINARY_DIR}/falcoctl-prefix/src/falcoctl/falcoctl" DESTINATION "${FALCO_BIN_DIR}" COMPONENT "${FALCO_COMPONENT_NAME}")
--- a/cmake/modules/falcosecurity-libs.cmake
+++ b/cmake/modules/falcosecurity-libs.cmake
@@ -27,15 +27,12 @@ else()
  # In case you want to test against another falcosecurity/libs version (or branch, or commit) just pass the variable -
  # ie., `cmake -DFALCOSECURITY_LIBS_VERSION=dev ..`
  if(NOT FALCOSECURITY_LIBS_VERSION)
-    set(FALCOSECURITY_LIBS_VERSION "2e9e6346eefeddd0afce7b6a06cb42d4265615dd")
-    set(FALCOSECURITY_LIBS_CHECKSUM "SHA256=d5f37545ddc456f1e1489800b856f9770d8a092f2bd5841893669a0b7eb5ed55")
+    set(FALCOSECURITY_LIBS_VERSION "dd443b67c6b04464cb8ee2771af8ada8777e7fac")
+    set(FALCOSECURITY_LIBS_CHECKSUM "SHA256=df373099d0f4cd4417a0103bb57f26c7412ffa86cde2bb2d579c6feba841626d")
  endif()

  # cd /path/to/build && cmake /path/to/source
-  execute_process(COMMAND "${CMAKE_COMMAND}"
-      -DCMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}"
-      -DFALCOSECURITY_LIBS_VERSION=${FALCOSECURITY_LIBS_VERSION}
-      -DFALCOSECURITY_LIBS_CHECKSUM=${FALCOSECURITY_LIBS_CHECKSUM}
+  execute_process(COMMAND "${CMAKE_COMMAND}" -DFALCOSECURITY_LIBS_VERSION=${FALCOSECURITY_LIBS_VERSION} -DFALCOSECURITY_LIBS_CHECKSUM=${FALCOSECURITY_LIBS_CHECKSUM}
    ${FALCOSECURITY_LIBS_CMAKE_SOURCE_DIR} WORKING_DIRECTORY ${FALCOSECURITY_LIBS_CMAKE_WORKING_DIR})

  # cmake --build .
--- a/cmake/modules/njson.cmake
+++ b/cmake/modules/njson.cmake
@@ -1,34 +0,0 @@
-#
-# Copyright (C) 2023 The Falco Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
-# the License. You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations under the License.
-#
-
-#
-# nlohmann-json
-#
-if(NJSON_INCLUDE)
-    # Adding the custom target we can use it with `add_dependencies()`
-    if(NOT TARGET njson)
-        add_custom_target(njson)
-    endif()
-else()
-    # We always use the bundled version
-    set(NJSON_SRC "${PROJECT_BINARY_DIR}/njson-prefix/src/njson")
-    set(NJSON_INCLUDE "${NJSON_SRC}/single_include")
-    ExternalProject_Add(
-        njson
-        URL "https://github.com/nlohmann/json/archive/v3.3.0.tar.gz"
-        URL_HASH "SHA256=2fd1d207b4669a7843296c41d3b6ac5b23d00dec48dba507ba051d14564aa801"
-        CONFIGURE_COMMAND ""
-        BUILD_COMMAND ""
-        INSTALL_COMMAND "")
-    message(STATUS "Using bundled nlohmann-json in '${NJSON_SRC}'")
-endif()
--- a/cmake/modules/plugins.cmake
+++ b/cmake/modules/plugins.cmake
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2023 The Falco Authors.
+# Copyright (C) 2021 The Falco Authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 # the License. You may obtain a copy of the License at
@@ -13,26 +13,22 @@

 include(ExternalProject)

-# 'stable' or 'dev'
-set(PLUGINS_DOWNLOAD_BUCKET "dev")
-
 string(TOLOWER ${CMAKE_HOST_SYSTEM_NAME} PLUGINS_SYSTEM_NAME)

 if(NOT DEFINED PLUGINS_COMPONENT_NAME)
    set(PLUGINS_COMPONENT_NAME "${CMAKE_PROJECT_NAME}-plugins")
 endif()

-# k8saudit
-set(PLUGIN_K8S_AUDIT_VERSION "0.5.3-0.5.3-27%2B7b07a4b")
+set(PLUGIN_K8S_AUDIT_VERSION "0.4.0")
 if(${CMAKE_HOST_SYSTEM_PROCESSOR} STREQUAL "x86_64")
-    set(PLUGIN_K8S_AUDIT_HASH "22c15e5aa2c86cf2216cd767f8766047696e9ba637d63c5ae5e00893f0efad9c")
+    set(PLUGIN_K8S_AUDIT_HASH "ded0b5419f40084547620ccc48b19768e5e89457b85cfe8fbe496ca72267a3a4")
 else() # aarch64
-    set(PLUGIN_K8S_AUDIT_HASH "564f95031b973296fd7ccdda6c4a4f6820bb6da8106bcd48a549a7fca8c02540")
+    set(PLUGIN_K8S_AUDIT_HASH "775cba666612114bc5b0c36f2e3c4557f5adbffcca2d77e72be87c6fcbf51ceb")
 endif()

 ExternalProject_Add(
  k8saudit-plugin
-  URL "https://download.falco.org/plugins/${PLUGINS_DOWNLOAD_BUCKET}/k8saudit-${PLUGIN_K8S_AUDIT_VERSION}-${PLUGINS_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}.tar.gz"
+  URL "https://download.falco.org/plugins/stable/k8saudit-${PLUGIN_K8S_AUDIT_VERSION}-${PLUGINS_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}.tar.gz"
  URL_HASH "SHA256=${PLUGIN_K8S_AUDIT_HASH}"
  CONFIGURE_COMMAND ""
  BUILD_COMMAND ""
@@ -42,25 +38,24 @@ install(FILES "${PROJECT_BINARY_DIR}/k8saudit-plugin-prefix/src/k8saudit-plugin/

 ExternalProject_Add(
  k8saudit-rules
-  URL "https://download.falco.org/plugins/${PLUGINS_DOWNLOAD_BUCKET}/k8saudit-rules-${PLUGIN_K8S_AUDIT_VERSION}.tar.gz"
-  URL_HASH "SHA256=d1add6c4dfe7e8aca85f536fd7577dd0d93662927ab604e6db6757e89b99f2b2"
+  URL "https://download.falco.org/plugins/stable/k8saudit-rules-${PLUGIN_K8S_AUDIT_VERSION}.tar.gz"
+  URL_HASH "SHA256=53948fac0345e718d673142a992ac820135f771141dfaa9719c7575ac8ae6878"
  CONFIGURE_COMMAND ""
  BUILD_COMMAND ""
  INSTALL_COMMAND "")

 install(FILES "${PROJECT_BINARY_DIR}/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml" DESTINATION "${FALCO_ETC_DIR}" COMPONENT "${PLUGINS_COMPONENT_NAME}")

-# cloudtrail
-set(PLUGIN_CLOUDTRAIL_VERSION "0.7.3-0.7.3-27%2B7b07a4b")
+set(PLUGIN_CLOUDTRAIL_VERSION "0.6.0")
 if(${CMAKE_HOST_SYSTEM_PROCESSOR} STREQUAL "x86_64")
-    set(PLUGIN_CLOUDTRAIL_HASH "856f5f5505c72776a188ba29633d81e5f21924b20c2cfb5a2da3f8f21410e248")
+    set(PLUGIN_CLOUDTRAIL_HASH "80e0c33f30c01a90efb7e9a671d978ff9679c462e3105020238abf31230e49a9")
 else() # aarch64
-    set(PLUGIN_CLOUDTRAIL_HASH "935a96d68f182cec0f650186355bb245e36fdd884a596442992b55f066993fc1")
+    set(PLUGIN_CLOUDTRAIL_HASH "a3e739932e66d44be848a68857fa15f56134d5246a1b9ab912c81f91b68fb23f")
 endif()

 ExternalProject_Add(
  cloudtrail-plugin
-  URL "https://download.falco.org/plugins/${PLUGINS_DOWNLOAD_BUCKET}/cloudtrail-${PLUGIN_CLOUDTRAIL_VERSION}-${PLUGINS_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}.tar.gz"
+  URL "https://download.falco.org/plugins/stable/cloudtrail-${PLUGIN_CLOUDTRAIL_VERSION}-${PLUGINS_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}.tar.gz"
  URL_HASH "SHA256=${PLUGIN_CLOUDTRAIL_HASH}"
  CONFIGURE_COMMAND ""
  BUILD_COMMAND ""
@@ -70,25 +65,24 @@ install(FILES "${PROJECT_BINARY_DIR}/cloudtrail-plugin-prefix/src/cloudtrail-plu

 ExternalProject_Add(
  cloudtrail-rules
-  URL "https://download.falco.org/plugins/${PLUGINS_DOWNLOAD_BUCKET}/cloudtrail-rules-${PLUGIN_CLOUDTRAIL_VERSION}.tar.gz"
-  URL_HASH "SHA256=4b92cb5f81be0734a87babbd48eb1dc15e1297168024072c3fd02ccee7550b73"
+  URL "https://download.falco.org/plugins/stable/cloudtrail-rules-${PLUGIN_CLOUDTRAIL_VERSION}.tar.gz"
+  URL_HASH "SHA256=e0dccb7b0f1d24b1e526a33ffd973ea5f2ac2879dbc999e119419ebfd24305ff"
  CONFIGURE_COMMAND ""
  BUILD_COMMAND ""
  INSTALL_COMMAND "")

-install(FILES "${PROJECT_BINARY_DIR}/cloudtrail-rules-prefix/src/cloudtrail-rules/aws_cloudtrail_rules.yaml" DESTINATION "${FALCO_ETC_DIR}" COMPONENT "${PLUGINS_COMPONENT_NAME}")
+  install(FILES "${PROJECT_BINARY_DIR}/cloudtrail-rules-prefix/src/cloudtrail-rules/aws_cloudtrail_rules.yaml" DESTINATION "${FALCO_ETC_DIR}" COMPONENT "${PLUGINS_COMPONENT_NAME}")

-# json
-set(PLUGIN_JSON_VERSION "0.6.2-0.6.2-30%2B7b07a4b")
+set(PLUGIN_JSON_VERSION "0.6.0")
 if(${CMAKE_HOST_SYSTEM_PROCESSOR} STREQUAL "x86_64")
-    set(PLUGIN_JSON_HASH "9d3ef271667d9662fd47672b59ccace800ae1cc4f6d4c6d34edc1d9e26a87179")
+    set(PLUGIN_JSON_HASH "15fb7eddd978e8bb03f05412e9446e264e4548d7423b3d724b99d6d87a8c1b27")
 else() # aarch64
-    set(PLUGIN_JSON_HASH "113a632f4dd05ef7c4537fafdc0114fbe736a1da10b8225d8aa1679442157d5b")
+    set(PLUGIN_JSON_HASH "4db23f35a750e10a5b7b54c9aa469a7587705e7faa22927e941b41f3c5533e9f")
 endif()

 ExternalProject_Add(
  json-plugin
-  URL "https://download.falco.org/plugins/${PLUGINS_DOWNLOAD_BUCKET}/json-${PLUGIN_JSON_VERSION}-${PLUGINS_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}.tar.gz"
+  URL "https://download.falco.org/plugins/stable/json-${PLUGIN_JSON_VERSION}-${PLUGINS_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}.tar.gz"
  URL_HASH "SHA256=${PLUGIN_JSON_HASH}"
  CONFIGURE_COMMAND ""
  BUILD_COMMAND ""
--- a/cmake/modules/yaml-cpp.cmake
+++ b/cmake/modules/yaml-cpp.cmake
@@ -19,7 +19,6 @@ if(NOT USE_BUNDLED_DEPS)
  else()
    message(FATAL_ERROR "Couldn't find system yamlcpp")
  endif()
-  add_custom_target(yamlcpp)
 else()
  set(YAMLCPP_SRC "${PROJECT_BINARY_DIR}/yamlcpp-prefix/src/yamlcpp")
  message(STATUS "Using bundled yaml-cpp in '${YAMLCPP_SRC}'")
--- a/docker/builder/README.md
+++ b/docker/builder/README.md
@@ -1,8 +0,0 @@
-# Builder folder
-
-* We use `Dockerfile` to build the `centos7` Falco builder image.
-* We use `modern-falco-builder.Dockerfile` to build Falco with the modern probe and return it as a Dockerfile output. This Dockerfile doesn't generate a Docker image but returns as output (through the `--output` command):
-  * Falco `tar.gz`.
-  * Falco `deb` package.
-  * Falco `rpm` package.
-  * Falco build directory, used by other CI jobs.
--- a/docker/builder/modern-falco-builder.Dockerfile
+++ b/docker/builder/modern-falco-builder.Dockerfile
@@ -1,60 +0,0 @@
-
-FROM centos:7 AS build-stage
-
-# To build Falco you need to pass the cmake option
-ARG CMAKE_OPTIONS=""
-ARG MAKE_JOBS=6
-
-# Install all the dependencies
-WORKDIR /
-
-RUN yum -y install centos-release-scl; \
-    yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++; \
-    source scl_source enable devtoolset-9; \
-    yum install -y git wget make m4 rpm-build
-
-# With some previous cmake versions it fails when downloading `zlib` with curl in the libs building phase
-RUN curl -L -o /tmp/cmake.tar.gz https://github.com/Kitware/CMake/releases/download/v3.22.5/cmake-3.22.5-linux-$(uname -m).tar.gz; \
-    gzip -d /tmp/cmake.tar.gz; \
-    tar -xpf /tmp/cmake.tar --directory=/tmp; \
-    cp -R /tmp/cmake-3.22.5-linux-$(uname -m)/* /usr; \
-    rm -rf /tmp/cmake-3.22.5-linux-$(uname -m)/
-
-# Copy Falco folder from the build context
-COPY . /source
-WORKDIR /build/release
-
-RUN source scl_source enable devtoolset-9; \
-    cmake ${CMAKE_OPTIONS} /source; \
-    make falco -j${MAKE_JOBS}
-RUN make package
-
-# We need `make all` for integration tests.
-RUN make all -j${MAKE_JOBS}
-
-FROM scratch AS export-stage
-
-ARG DEST_BUILD_DIR="/build"
-
-COPY --from=build-stage /build/release/falco-*.tar.gz /packages/
-COPY --from=build-stage /build/release/falco-*.deb /packages/
-COPY --from=build-stage /build/release/falco-*.rpm /packages/
-
-# This is what we need for integration tests. We don't export all the build directory
-# outside the container since its size is almost 6 GB, we export only what is strictly necessary
-# for integration tests.
-# This is just a workaround to fix the CI build until we replace our actual testing framework.
-COPY --from=build-stage /build/release/cloudtrail-plugin-prefix ${DEST_BUILD_DIR}/cloudtrail-plugin-prefix
-COPY --from=build-stage /build/release/cloudtrail-rules-prefix ${DEST_BUILD_DIR}/cloudtrail-rules-prefix
-COPY --from=build-stage /build/release/falcosecurity-rules-falco-prefix ${DEST_BUILD_DIR}/falcosecurity-rules-falco-prefix
-COPY --from=build-stage /build/release/falcosecurity-rules-local-prefix ${DEST_BUILD_DIR}/falcosecurity-rules-local-prefix
-COPY --from=build-stage /build/release/json-plugin-prefix ${DEST_BUILD_DIR}/json-plugin-prefix
-COPY --from=build-stage /build/release/k8saudit-plugin-prefix ${DEST_BUILD_DIR}/k8saudit-plugin-prefix
-COPY --from=build-stage /build/release/k8saudit-rules-prefix ${DEST_BUILD_DIR}/k8saudit-rules-prefix
-COPY --from=build-stage /build/release/scripts ${DEST_BUILD_DIR}/scripts
-COPY --from=build-stage /build/release/test ${DEST_BUILD_DIR}/test
-COPY --from=build-stage /build/release/userspace/falco/falco ${DEST_BUILD_DIR}/userspace/falco/falco
-COPY --from=build-stage /build/release/userspace/falco/config_falco.h ${DEST_BUILD_DIR}/userspace/falco/config_falco.h
-COPY --from=build-stage /build/release/falco-*.tar.gz ${DEST_BUILD_DIR}/
-COPY --from=build-stage /build/release/falco-*.deb ${DEST_BUILD_DIR}/
-COPY --from=build-stage /build/release/falco-*.rpm ${DEST_BUILD_DIR}/
--- a/docker/driver-loader/Dockerfile
+++ b/docker/driver-loader/Dockerfile
@@ -1,5 +1,5 @@
 ARG FALCO_IMAGE_TAG=latest
-FROM docker.io/falcosecurity/falco:${FALCO_IMAGE_TAG}
+FROM falcosecurity/falco:${FALCO_IMAGE_TAG}

 LABEL maintainer="cncf-falco-dev@lists.cncf.io"

--- a/docker/falco/Dockerfile
+++ b/docker/falco/Dockerfile
@@ -88,7 +88,7 @@ RUN rm -rf /usr/bin/clang \
 	&& ln -s /usr/bin/clang-7 /usr/bin/clang \
 	&& ln -s /usr/bin/llc-7 /usr/bin/llc

-RUN curl -s https://falco.org/repo/falcosecurity-packages.asc | apt-key add - \
+RUN curl -s https://falco.org/repo/falcosecurity-3672BA8F.asc | apt-key add - \
 	&& echo "deb https://download.falco.org/packages/${VERSION_BUCKET} stable main" | tee -a /etc/apt/sources.list.d/falcosecurity.list \
 	&& apt-get update -y \
 	&& if [ "$FALCO_VERSION" = "latest" ]; then apt-get install -y --no-install-recommends falco; else apt-get install -y --no-install-recommends falco=${FALCO_VERSION}; fi \
--- a/docker/no-driver/Dockerfile
+++ b/docker/no-driver/Dockerfile
@@ -6,7 +6,7 @@ ARG VERSION_BUCKET=bin
 ENV FALCO_VERSION=${FALCO_VERSION}
 ENV VERSION_BUCKET=${VERSION_BUCKET}

-RUN apt-get -y update && apt-get -y install gridsite-clients curl ca-certificates
+RUN apt-get -y update && apt-get -y install gridsite-clients curl

 WORKDIR /

@@ -27,8 +27,6 @@ LABEL maintainer="cncf-falco-dev@lists.cncf.io"
 LABEL usage="docker run -i -t --privileged -v /var/run/docker.sock:/host/var/run/docker.sock -v /dev:/host/dev -v /proc:/host/proc:ro --name NAME IMAGE"
 # NOTE: for the "least privileged" use case, please refer to the official documentation

-RUN apt-get -y update && apt-get -y install ca-certificates
-
 ENV HOST_ROOT /host
 ENV HOME /root

--- a/docker/tester/Dockerfile
+++ b/docker/tester/Dockerfile
@@ -15,7 +15,7 @@ RUN if [ "$TARGETARCH" = "amd64" ] ; then curl -L -o grpcurl.tar.gz \
    https://github.com/fullstorydev/grpcurl/releases/download/v1.8.6/grpcurl_1.8.6_linux_arm64.tar.gz; \
    fi;

-RUN dnf install -y python-pip python docker findutils jq unzip sed curl && dnf clean all
+RUN dnf install -y python-pip python docker findutils jq unzip && dnf clean all
 ENV PATH="/root/.local/bin/:${PATH}"
 RUN pip install --user avocado-framework==69.0
 RUN pip install --user avocado-framework-plugin-varianter-yaml-to-mux==69.0
--- a/falco.yaml
+++ b/falco.yaml
@@ -170,13 +170,6 @@ syscall_event_drops:
 syscall_event_timeouts:
  max_consecutives: 1000

-# Enabling this option allows Falco to drop failed syscalls exit events
-# in the kernel driver before the event is pushed onto the ring buffer.
-# This can enable some small optimization both in CPU usage and ring buffer usage,
-# possibly leading to lower number of event losses.
-# Be careful: enabling it also means losing a bit of visibility on the system.
-syscall_drop_failed_exit: false
-
 # --- [Description]
 #
 # This is an index that controls the dimension of the syscall buffers.
@@ -232,72 +225,6 @@ syscall_drop_failed_exit: false

 syscall_buf_size_preset: 4

-############## Modern BPF probe specific ##############
-# Please note: these configs regard only the modern BPF probe.
-#
-# `cpus_for_each_syscall_buffer`
-#
-# --- [Description]
-#
-# This is an index that controls how many CPUs you want to assign to a single
-# syscall buffer (ring buffer). By default, every syscall buffer is associated to
-# 2 CPUs, so the mapping is 1:2. The modern BPF probe allows you to choose different
-# mappings, for example, 1:1 would mean a syscall buffer for each CPU.
-#
-# --- [Usage]
-#
-# You can choose between different indexes: from `0` to `MAX_NUMBER_ONLINE_CPUs`.
-# `0` is a special value and it means a single syscall buffer shared between all
-# your online CPUs. `0` has the same effect as `MAX_NUMBER_ONLINE_CPUs`, the rationale
-# is that `0` allows you to create a single buffer without knowing the number of online
-# CPUs on your system.
-# Let's consider an example to better understand it:
-#
-# Consider a system with 7 online CPUs:
-#
-#          CPUs     0  X  2  3  X  X  6  7  8  9   (X means offline CPU)
-#
-# - `1` means a syscall buffer for each CPU so 7 buffers
-#
-#          CPUs     0  X  2  3  X  X  6  7  8  9   (X means offline CPU)
-#                   |     |  |        |  |  |  |
-#       BUFFERs     0     1  2        3  4  5  6
-#
-# - `2` (Default value) means a syscall buffer for each CPU pair, so 4 buffers
-#
-#          CPUs     0  X  2  3  X  X  6  7  8  9   (X means offline CPU)
-#                   |     |  |        |  |  |  |
-#       BUFFERs     0     0  1        1  2  2  3
-#
-# Please note that we need 4 buffers, 3 buffers are associated with CPU pairs, the last
-# one is mapped with just 1 CPU since we have an odd number of CPUs.
-#
-# - `0` or `MAX_NUMBER_ONLINE_CPUs` mean a syscall buffer shared between all CPUs, so 1 buffer
-#
-#          CPUs     0  X  2  3  X  X  6  7  8  9   (X means offline CPU)
-#                   |     |  |        |  |  |  |
-#       BUFFERs     0     0  0        0  0  0  0
-#
-# Moreover you can combine this param with `syscall_buf_size_preset`
-# index, for example, you could create a huge single syscall buffer
-# shared between all your online CPUs of 512 MB (so `syscall_buf_size_preset=10`).
-#
-# --- [Suggestions]
-#
-# We chose index `2` (so one syscall buffer for each CPU pair) as default because the modern bpf probe
-# follows a different memory allocation strategy with respect to the other 2 drivers (bpf and kernel module).
-# By the way, you are free to find the preferred configuration for your system.
-# Considering a fixed `syscall_buf_size_preset` and so a fixed buffer dimension:
-# - a lower number of buffers can speed up your system (lower memory footprint)
-# - a too lower number of buffers could increase contention in the kernel causing an
-#   overall slowdown of the system.
-# If you don't have huge events throughputs and you are not experimenting with tons of drops
-# you can try to reduce the number of buffers to have a lower memory footprint
-
-modern_bpf:
-  cpus_for_each_syscall_buffer: 2
-############## Modern BPF probe specific ##############
-
 # Falco continuously monitors outputs performance. When an output channel does not allow
 # to deliver an alert within a given deadline, an error is reported indicating
 # which output is blocking notifications.
@@ -356,17 +283,10 @@ file_output:
 stdout_output:
  enabled: true

-# Falco supports an embedded webserver and exposes the following endpoints:
-# - /healthz: health endpoint useful for checking if Falco is up and running
-#   (the endpoint name is configurable).
-# - /versions: responds with a JSON object containing version numbers of the
-#   internal Falco components (similar output as `falco --version -o json_output=true`).
-#
-# # NOTE: the /versions endpoint is useful to other services (such as falcoctl)
-# to retrieve info about a running Falco instance. Make sure the webserver is
-# enabled if you're using falcoctl either locally or with Kubernetes.
-#
-# The following options control the behavior of that webserver (enabled by default).
+# Falco contains an embedded webserver that is used to implement an health
+# endpoint for checking if Falco is up and running. These config options control
+# the behavior of that webserver. By default, the webserver is enabled and
+# the endpoint is /healthz.
 #
 # The ssl_certificate is a combination SSL Certificate and corresponding
 # key contained in a single file. You can generate a key/cert as follows:
@@ -407,15 +327,6 @@ http_output:
  enabled: false
  url: http://some.url
  user_agent: "falcosecurity/falco"
-  # Tell Falco to not verify the remote server.
-  insecure: false
-  # Path to the CA certificate that can verify the remote server.
-  ca_cert: ""
-  # Path to a specific file that will be used as the CA certificate store.
-  ca_bundle: ""
-  # Path to a folder that will be used as the CA certificate store. CA certificate need to be
-  # stored as indivitual PEM files in this directory.
-  ca_path: "/etc/ssl/certs"

 # Falco supports running a gRPC server with two main binding types
 # 1. Over the network with mandatory mutual TLS authentication (mTLS)
@@ -457,111 +368,3 @@ metadata_download:
  max_mb: 100
  chunk_wait_us: 1000
  watch_freq_sec: 1
-
-
-# base_syscalls ! [EXPERIMENTAL] Use with caution, read carefully !
-#
-# --- [Description]
-#
-# This option configures the set of syscalls that Falco traces.
-#
-# --- [Falco's State Engine]
-#
-# Falco requires a set of syscalls to build up state in userspace.
-# For example, when spawning a new process or network connection, multiple syscalls are involved.
-# Furthermore, properties of a process during its lifetime can be modified by
-# syscalls. Falco accounts for this by enabling the collection of additional syscalls than the
-# ones defined in the rules and by managing a smart process cache table in
-# userspace. Processes are purged from this table when a process exits.
-#
-# By default, with
-#   ```
-#   base_syscalls.custom_set = []
-#   base_syscalls.repair = false
-#   ```
-# Falco enables tracing for a syscall set gathered:
-#   (1) from (enabled) Falco rules
-#   (2) from a static, more verbose set defined in `libsinsp::events::sinsp_state_sc_set` in libs/userspace/libsinsp/events/sinsp_events_ppm_sc.cpp
-# This allows Falco to successfully build up it's state engine and life-cycle management.
-#
-# If the default behavior described above does not fit the user's use case for Falco,
-# the `base_syscalls` option allows for finer end-user control of syscalls traced by Falco.
-#
-# --- [ base_syscalls.custom_set ]
-#
-# CAUTION: Misconfiguration of this setting may result in incomplete Falco event
-# logs or Falco being unable to trace events entirely.
-#
-# `base_syscalls.custom_set` allows the user to explicitly define an additional
-# set of syscalls to be traced in addition to the syscalls from each enabled Falco rule.
-#
-# This is useful in lowering CPU utilization and further tailoring Falco to
-# specific environments according to your threat model and budget constraints.
-#
-# --- [ base_syscalls.repair ]
-#
-# `base_syscalls.repair` is an alternative to Falco's default state engine enforcement.
-# When enabled, this option is designed to
-#   (1) ensure that Falco's state engine is correctly and successfully built-up
-#   (2) be the most system resource-friendly by activating the least number of
-#       additional syscalls (outside of those enabled for enabled rules)
-#
-# Setting `base_syscalls.repair` to `true` allows Falco to automatically configure
-# what is described in the [Suggestions] section below.
-#
-# `base_syscalls.repair` can be enabled with an empty custom set, meaning with the following,
-#   ```
-#   base_syscalls.custom_set = []
-#   base_syscalls.repair = true
-#   ```
-# Falco enables tracing for a syscall set gathered:
-#   (1) from (enabled) Falco rules
-#   (2) from minimal set of additional syscalls needed to "repair" the
-#       state engine and properly log event conditions specified in enabled Falco rules
-#
-# --- [Usage]
-#
-# List of system calls names (<syscall-name>), negative ("!<syscall-name>") notation supported.
-#
-# Example:
-# base_syscalls.custom_set: [<syscall-name>, <syscall-name>, "!<syscall-name>"]
-# base_syscalls.repair: <bool>
-#
-# We recommend to only exclude syscalls, e.g. "!mprotect" if you need a fast deployment update
-# (overriding rules), else remove unwanted syscalls from the Falco rules.
-#
-# Passing `-o "log_level=debug" -o "log_stderr=true" --dry-run` to Falco's
-# cmd args will print the final set of syscalls to STDOUT.
-#
-# --- [Suggestions]
-#
-# NOTE: setting `base_syscalls.repair: true` automates the following suggestions for you.
-#
-# These suggestions are subject to change as Falco and its state engine evolve.
-#
-# For execve* events:
-# Some Falco fields for an execve* syscall are retrieved from the associated
-# `clone`, `clone3`, `fork`, `vfork` syscalls when spawning a new process.
-# The `close` syscall is used to purge file descriptors from Falco's internal
-# thread / process cache table and is necessary for rules relating to file
-# descriptors (e.g. open, openat, openat2, socket, connect, accept, accept4 ... and many more)
-#
-# Consider enabling the following syscalls in `base_syscalls.custom_set` for process rules:
-# [clone, clone3, fork, vfork, execve, execveat, close]
-#
-# For networking related events:
-# While you can log `connect` or `accept*` syscalls without the socket syscall,
-# the log will not contain the ip tuples.
-# Additionally, for `listen` and `accept*` syscalls, the `bind` syscall is also necessary.
-#
-# We recommend the following as the minimum set for networking-related rules:
-# [clone, clone3, fork, vfork, execve, execveat, close, socket, bind, getsockopt]
-#
-# Lastly, for tracking the correct `uid`, `gid` or `sid`, `pgid` of a process when the
-# running process opens a file or makes a network connection, consider adding the
-# following to the above recommended syscall sets:
-# ... setresuid, setsid, setuid, setgid, setpgid, setresgid, setsid, capset, chdir, chroot, fchdir ...
-#
-base_syscalls:
-  custom_set: []
-  repair: false
--- a/proposals/20221129-artifacts-distribution.md
+++ b/proposals/20221129-artifacts-distribution.md
@@ -1,173 +0,0 @@
-# Artifacts distribution
-
-This proposal aims to define guidelines for the official distribution of artifacts published by Falcosecurity. 
-
-Therefore, to create a unified management of the distribution of artifacts, this document supersedes (for the parts concerning the distributions of artifacts) proposals [Falco Artifacts Scope - Part 1](https://github.com/falcosecurity/falco/blob/master/proposals/20200506-artifacts-scope-part-1.md), [Falco Artifacts Scope - Part 2](https://github.com/falcosecurity/falco/blob/master/proposals/20200506-artifacts-scope-part-2.md), and [Falco Drivers Storage S3](https://github.com/falcosecurity/falco/blob/master/proposals/20201025-drivers-storage-s3.md) and also extends and generalizes the proposal [Falco Rules and Plugin distribution](https://github.com/falcosecurity/falcoctl/blob/main/proposals/20220916-rules-and-plugin-distribution.md) for [falcoctl](https://github.com/falcosecurity/falcoctl).
-
-## Goals
-
- Allow users to consume artifacts in a consistent way
- Define official artifacts
- Unify distribution mechanism, infrastructure and tooling
- Provide generic guidelines applicable to any artifact to be distributed
-
-## Non-Goals
-
- Infra/CI implementation details
- Supply chain security topics
-
-## Proposal
-
-With officially supported artifacts, we mean that set of artifacts published 
-by Falcosecurity as part of Falco or its ecosystem.
-
-At the time of writing, the Falcosecurity organization distributes several kinds of artifacts in the form of files or container images. They include:
- Installation packages
- Helm charts
- Drivers (eg, kmod, eBPF)
- Rule files
- Plugins
- Other kinds may be added in the future.
-
-Features shipped with **official artifacts are intended for general availability(GA)**, unless otherwise specified (eg. if experimental or non-production ready features are present, they must be indicated in the release notes). 
-
-The same artifacts can be distributed via multiple distribution channels, and each channel can be mirrored. **The [falco.org](https://falco.org/) website must list all official distribution channels and mirrors**. Any distribution channel not listed on our official website must not be considered part of the official distribution. However, maintainers can still use other channels for experimentation or incubating projects eventually.
-
-### Distribution channels
-
-#### HTTP Distribution
-
-Distributing artifacts as plain files via HTTP is mostly intended for **humans, simple and legacy clients** (e.g., a shell script that downloads a file). 
-
-The allowed publishing channels are:
- **[download.falco.org](https://download.falco.org/)** where most of the file artifacts lives
- **endpoints made available by GitHub** for the Falcosecurity organization (e.g., release download URL, GitHub pages, etc.).
-
-Typically, all official artifacts that can be shipped as plain files should be published at [download.falco.org](https://download.falco.org/) and available for download. 
-
-Using the GitHub platform is allowed as an alternative assuming that artifacts are published under the Falcosecurity organization and the GitHub platform usage limitations are being respected (a notable example is publishing a [Helm chart index file using GitHub pages](https://falcosecurity.github.io/charts/)).
-
-It is allowed to publish other non-official artifacts (for example, [development builds](https://download.falco.org/?prefix=packages/bin-dev/)), taking that those are correctly denoted.
-
-Introducing other HTTP channels is discouraged. Providing mirrors is discouraged unless required for technical reasons.
-
-#### OCI Distribution
-
-Some artifacts are in the form of Open Container Initiative (OCI) images and require OCI registries to be distributed. Nevertheless, since the [OCI Distribution Spec](https://specs.opencontainers.org/distribution-spec/?v=v1.0.0) allows any content, even regular files can be stored in OCI registries and distributed likewise. Notably, the [Helm project in early 2022 started storing charts in OCI](https://helm.sh/blog/storing-charts-in-oci/) registries. One our tool [falcoctl did the same](https://github.com/falcosecurity/falcoctl/blob/main/proposals/20220916-rules-and-plugin-distribution.md) later.
-
-Distributing artifacts via OCI registries is intended for all compatible consumers (i.e., [falcoctl](https://github.com/falcosecurity/falcoctl)). It is **allowed and encouraged for any artifacts**. All official artifacts should be published so.
-
-The allowed publishing channels are:
-
-
-| Registry | Name | Account URL |
-| -------- | -------- | -------- |
-| `docker.io`    | Docker Hub     | https://hub.docker.com/u/falcosecurity |
-| `ghcr.io`    | Github Packages Container registry     | https://github.com/orgs/falcosecurity/packages |
-
-
-Both channels are equivalent and may publish the same artifacts. However, for historical reasons and to avoid confusion, the **`docker.io` registry should only be used for container images** and not for other kinds of artifacts (e.g., plugins, rules, etc.).
-
-
-Mirrors are allowed and encouraged if they facilitate artifacts consumption by our users. This proposal reccomends to enable mirrors on the major public OCI registry, such as [Amazon ECR](https://gallery.ecr.aws/) (which is already implentend in our infra at the time of writing).
-
-
-Official **channels and mirrors must be listed at [falco.org](https://falco.org/)**. 
-
-It is allowed to publish other non-official artifacts, even using image tags, taking that those are correctly denoted.
-
-
-#### Other channels
-
-At the time of writing, no other distribution channels are present or needed. However, in case a new kind of artifact will require a particular distribution mechanism (for example, in case an existing package manager system need to consume the artifact using its protocol), the rule of thumb is first to use the available GitHub features for the Falcosecurity organization, if possible. Users will quickly recognize the association between the artifact and the publisher (i.e., falcosecurity), and for that reason is usually preferable.
-
-In all other cases, introducing a new distribution channel must require extensive discussion among maintainers. Nevertheless, **introducing too many distribution channels is discouraged** because it disperses the effort and can mislead users. 
-
-
-### Publishing
-
-#### Source repository
-
-Artifacts must always be built starting from the originating source code and thru an auditable and reproducible process that runs on our infra. It's recommended that the naming and versioning of the published artifact consistently match the originating repository's naming and versioning. For example, the package `falco-0.33.0-x86_64.tar.gz` must match the source code of the git tag [0.33.0](https://github.com/falcosecurity/falco/tree/0.33.0) of the [falco](https://github.com/falcosecurity/falco) repository.
-
-It's recommended that **each repository publish only one kind of artifact** associated with it. 
-
-Exceptions are allowed for:
- - mono repos (notably [charts](https://github.com/falcosecurity/charts) and [plugins](https://github.com/falcosecurity/plugins)), 
- - or whenever technical constraints impose a different approach (notably, our Driver Build Grid lives on [test-infra](https://github.com/falcosecurity/test-infra), but the source code is in [libs](https://github.com/falcosecurity/libs)).
-
-Exceptions should be documented to avoid the users and contributors might be confused.
-
-#### Namespacing
-
-As a general rule, to avoid name clashing among different projects under the Falcosecurity organization, all **published artifacts should reflect the originating repository name** in their publishing URL. For example, all artifacts generated by the [falcosecurity/plugins](https://github.com/falcosecurity/plugins) repository should have `falcosecurity/plugins` as the URL's base path.
-
-Exceptions are allowed for:
- legacy and already published artifacts (to avoid disruption);
- justified technical reasons.
-
-#### Versioning
-
-All published artifacts must be labeled with version numbers following the **[Semantic Versioning 2 specification](https://semver.org/)**.
-
-For the [HTTP Distribution](#http-distribution), the version number must be reflected in the file name (including build metadata like the targeted arch and platform).
-
-For the [OCI Distribution](#oci-distribution), the version number must be reflected in the image tag (build metadata may be avoided if included in the manifest).
-
-### Tooling
-
-Tooling is essential to deliver a consistent and straightforward UX to our users since the limited set of distribution channels is acceptable to provide just one (or a limited set of) tool(s) capable of working with various artifacts published by the Falcosecurity organization.
-
-In this regard, this proposal follows up the [Falco Rules and Plugin distribution](https://github.com/falcosecurity/falcoctl/blob/main/proposals/20220916-rules-and-plugin-distribution.md) proposal and recommends to use of **[falcoctl](https://github.com/falcosecurity/falcoctl) as the tool to managing artifacts specifically intended for Falco**. The tool's design should consider that other kinds of artifacts may be added in the future.
-
-Likewise, relying on existing **third-party tools for generic or well-known kinds of artifacts** (for example, Helm charts) is recommended.
-
-### Ecosystem
-
-Compatibility with other tools on the broader cloud native ecosystem should be considered when dealing with artifacts and their distribution.
-
-It is also recommended to use third-party solutions and projects that facilitate our users' discovery of published artifacts (for example, https://artifacthub.io/).
-
-
-## Action items
-
-The following subsections indicate major action items to be executed in order to transition from the current to the desiderate state of the art, as noted in this proposal.
-
-### Move [Falco rules](https://github.com/falcosecurity/falco/tree/master/rules) to their own repo
-
-Falco rules files (i.e., the ruleset for the data source syscall) are currently only distributed in bundles with Falco. However, now falcoctl can manage rules artifacts so that we can ship them separately.
-
-The benefits of having rules living in their repository are:
-  - dedicated versioning
-  - rules release will not be tied anymore to a Falco release (e.g., no need to wait for the scheduled Falco release to publish a new rule aiming to detect the latest published CVE)
-  - consistent installation/update mechanism with other rulesets (plugins rules are already published in their repository and can be consumed by falcoctl)
-
-Note that this change will not introduce a breaking change: Falco will continue shipping the default ruleset by including the published ruleset package.
-
-### Make `falcoctl` official
-
-Considering the centrality of falcoctl for managing official artifacts for Falco, the falcoctl project must be promoted to "Official" status, and its repository assumed to be [core](https://github.com/falcosecurity/evolution/blob/main/GOVERNANCE.md#core-repositories).
-
-### Deprecate `falco-driver-loader`
-
-At the time of writing, `falco-driver-loader` is a shell script shipped in a bundle with Falco that has the responsibility of installing a driver by either downloading it from our distribution channels or trying to build it on-the-fly.
-
-Our experience showed all the limitations of this approach, and it's now clear that such as script is hard to maintain. Furthermore, its responsibility overlaps with our aim to use `falcoctl` as the tool for managing artifacts.
-
-Thus, this proposal mandates to deprecate of `falco-driver-loader` in favor of `falcoctl.`
-
-However, to avoid user disruption and breaking legacy use case, it's recommended to provide still a faced script that exposes the same command line usage of `falco-driver-loader` but forward its execution to the new tool `falcoctl`.
-
-This implicitly requires that `falcoctl` be shipped in a bundle with Falco.
-
-### Update the documentation
-
-This proposal mandates making use of official documentation (i.e., falco.org) to state official items, such as artifacts, distribution channels, and mirrors.
-
-For that reason, it becomes imperative to update the documentation periodically concerning the list of officially supported distribution channels and mirrors.
-
-### Usage of GitHub Packages
-
-Since GitHub is the primary platform where the Falcosecurity organization hosts its code and infrastructure, its provided features should be preferred whenever possible.
-
-This proposal recommends using the GitHub Packages feature when the need to distribute a new kind of artifact arises. Such as convention should be adopted among all repositories of the organization.
--- a/1
+++ b/1
@@ -1 +0,0 @@
-./submodules/falcosecurity-rules/rules
--- a/cmake/modules/rules.cmake
+++ b/cmake/modules/rules.cmake
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2023 The Falco Authors.
+# Copyright (C) 2019 The Falco Authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 # the License. You may obtain a copy of the License at
@@ -11,26 +11,8 @@
 # specific language governing permissions and limitations under the License.
 #

+# GNU standard installation directories' definitions
 include(GNUInstallDirs)
-include(ExternalProject)
-
-# falco_rules.yaml
-set(FALCOSECURITY_RULES_FALCO_VERSION "falco-rules-0.1.0")
-set(FALCOSECURITY_RULES_FALCO_CHECKSUM "SHA256=0d3705a4650f09d10e7831b16e7af59c1da34ff19e788896e9ee77010014db4d")
-set(FALCOSECURITY_RULES_FALCO_PATH "${PROJECT_BINARY_DIR}/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml")
-ExternalProject_Add(
-  falcosecurity-rules-falco
-  URL "https://download.falco.org/rules/${FALCOSECURITY_RULES_FALCO_VERSION}.tar.gz"
-  URL_HASH "${FALCOSECURITY_RULES_FALCO_CHECKSUM}"
-  CONFIGURE_COMMAND ""
-  BUILD_COMMAND ""
-  INSTALL_COMMAND ""
-  TEST_COMMAND ""
-)
-
-# falco_rules.local.yaml
-set(FALCOSECURITY_RULES_LOCAL_PATH "${PROJECT_BINARY_DIR}/falcosecurity-rules-local-prefix/falco_rules.local.yaml")
-file(WRITE "${FALCOSECURITY_RULES_LOCAL_PATH}" "# Your custom rules!\n")

 if(NOT DEFINED FALCO_ETC_DIR)
  set(FALCO_ETC_DIR "${CMAKE_INSTALL_FULL_SYSCONFDIR}/falco")
@@ -39,32 +21,40 @@ endif()
 if(NOT DEFINED FALCO_RULES_DEST_FILENAME)
  set(FALCO_RULES_DEST_FILENAME "falco_rules.yaml")
  set(FALCO_LOCAL_RULES_DEST_FILENAME "falco_rules.local.yaml")
+  set(FALCO_APP_RULES_DEST_FILENAME "application_rules.yaml")
 endif()

+
 if(DEFINED FALCO_COMPONENT) # Allow a slim version of Falco to be embedded in other projects, intentionally *not* installing all rulesets.
  install(
-    FILES "${FALCOSECURITY_RULES_FALCO_PATH}"
+    FILES falco_rules.yaml
    COMPONENT "${FALCO_COMPONENT}"
    DESTINATION "${FALCO_ETC_DIR}"
    RENAME "${FALCO_RULES_DEST_FILENAME}")

  install(
-    FILES "${FALCOSECURITY_RULES_LOCAL_PATH}"
+    FILES falco_rules.local.yaml
    COMPONENT "${FALCO_COMPONENT}"
    DESTINATION "${FALCO_ETC_DIR}"
    RENAME "${FALCO_LOCAL_RULES_DEST_FILENAME}")
 else() # Default Falco installation
  install(
-    FILES "${FALCOSECURITY_RULES_FALCO_PATH}"
+    FILES falco_rules.yaml
    DESTINATION "${FALCO_ETC_DIR}"
    RENAME "${FALCO_RULES_DEST_FILENAME}"
    COMPONENT "${FALCO_COMPONENT_NAME}")

  install(
-    FILES "${FALCOSECURITY_RULES_LOCAL_PATH}"
+    FILES falco_rules.local.yaml
    DESTINATION "${FALCO_ETC_DIR}"
    RENAME "${FALCO_LOCAL_RULES_DEST_FILENAME}"
    COMPONENT "${FALCO_COMPONENT_NAME}")

+  install(
+    FILES application_rules.yaml
+    DESTINATION "${FALCO_ETC_DIR}/rules.available"
+    RENAME "${FALCO_APP_RULES_DEST_FILENAME}"
+    COMPONENT "${FALCO_COMPONENT_NAME}")
+
  install(DIRECTORY DESTINATION "${FALCO_ETC_DIR}/rules.d" COMPONENT "${FALCO_COMPONENT_NAME}")
 endif()
--- a/rules/OWNERS
+++ b/rules/OWNERS
@@ -0,0 +1,10 @@
+approvers:
+  - mstemm
+reviewers:
+  - leodido
+  - fntlnz
+  - mfdii
+  - kaizhe
+  - darryk10
+labels:
+  - area/rules
--- a/rules/application_rules.yaml
+++ b/rules/application_rules.yaml
@@ -0,0 +1,188 @@
+#
+# Copyright (C) 2019 The Falco Authors.
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+- required_engine_version: 2
+
+################################################################
+# By default all application-related rules are disabled for
+# performance reasons. Depending on the application(s) you use,
+# uncomment the corresponding rule definitions for
+# application-specific activity monitoring.
+################################################################
+
+# Elasticsearch ports
+- macro: elasticsearch_cluster_port
+  condition: fd.sport=9300
+- macro: elasticsearch_api_port
+  condition: fd.sport=9200
+- macro: elasticsearch_port
+  condition: elasticsearch_cluster_port or elasticsearch_api_port
+
+# - rule: Elasticsearch unexpected network inbound traffic
+#   desc: inbound network traffic to elasticsearch on a port other than the standard ports
+#   condition: user.name = elasticsearch and inbound and not elasticsearch_port
+#   output: "Inbound network traffic to Elasticsearch on unexpected port (connection=%fd.name)"
+#   priority: WARNING
+
+# - rule: Elasticsearch unexpected network outbound traffic
+#   desc: outbound network traffic from elasticsearch on a port other than the standard ports
+#   condition: user.name = elasticsearch and outbound and not elasticsearch_cluster_port
+#   output: "Outbound network traffic from Elasticsearch on unexpected port (connection=%fd.name)"
+#   priority: WARNING
+
+
+# ActiveMQ ports
+- macro: activemq_cluster_port
+  condition: fd.sport=61616
+- macro: activemq_web_port
+  condition: fd.sport=8161
+- macro: activemq_port
+  condition: activemq_web_port or activemq_cluster_port
+
+# - rule: Activemq unexpected network inbound traffic
+#   desc: inbound network traffic to activemq on a port other than the standard ports
+#   condition: user.name = activemq and inbound and not activemq_port
+#   output: "Inbound network traffic to ActiveMQ on unexpected port (connection=%fd.name)"
+#   priority: WARNING
+
+# - rule: Activemq unexpected network outbound traffic
+#   desc: outbound network traffic from activemq on a port other than the standard ports
+#   condition: user.name = activemq and outbound and not activemq_cluster_port
+#   output: "Outbound network traffic from ActiveMQ on unexpected port (connection=%fd.name)"
+#   priority: WARNING
+
+
+# Cassandra ports
+# https://docs.datastax.com/en/cassandra/2.0/cassandra/security/secureFireWall_r.html
+- macro: cassandra_thrift_client_port
+  condition: fd.sport=9160
+- macro: cassandra_cql_port
+  condition: fd.sport=9042
+- macro: cassandra_cluster_port
+  condition: fd.sport=7000
+- macro: cassandra_ssl_cluster_port
+  condition: fd.sport=7001
+- macro: cassandra_jmx_port
+  condition: fd.sport=7199
+- macro: cassandra_port
+  condition: >
+    cassandra_thrift_client_port or
+    cassandra_cql_port or cassandra_cluster_port or
+    cassandra_ssl_cluster_port or cassandra_jmx_port
+
+# - rule: Cassandra unexpected network inbound traffic
+#   desc: inbound network traffic to cassandra on a port other than the standard ports
+#   condition: user.name = cassandra and inbound and not cassandra_port
+#   output: "Inbound network traffic to Cassandra on unexpected port (connection=%fd.name)"
+#   priority: WARNING
+
+# - rule: Cassandra unexpected network outbound traffic
+#   desc: outbound network traffic from cassandra on a port other than the standard ports
+#   condition: user.name = cassandra and outbound and not (cassandra_ssl_cluster_port or cassandra_cluster_port)
+#   output: "Outbound network traffic from Cassandra on unexpected port (connection=%fd.name)"
+#   priority: WARNING
+
+# Couchdb ports
+# https://github.com/davisp/couchdb/blob/master/etc/couchdb/local.ini
+- macro: couchdb_httpd_port
+  condition: fd.sport=5984
+- macro: couchdb_httpd_ssl_port
+  condition: fd.sport=6984
+# xxx can't tell what clustering ports are used. not writing rules for this
+# yet.
+
+# Fluentd ports
+- macro: fluentd_http_port
+  condition: fd.sport=9880
+- macro: fluentd_forward_port
+  condition: fd.sport=24224
+
+# - rule: Fluentd unexpected network inbound traffic
+#   desc: inbound network traffic to fluentd on a port other than the standard ports
+#   condition: user.name = td-agent and inbound and not (fluentd_forward_port or fluentd_http_port)
+#   output: "Inbound network traffic to Fluentd on unexpected port (connection=%fd.name)"
+#   priority: WARNING
+
+# - rule: Tdagent unexpected network outbound traffic
+#   desc: outbound network traffic from fluentd on a port other than the standard ports
+#   condition: user.name = td-agent and outbound and not fluentd_forward_port
+#   output: "Outbound network traffic from Fluentd on unexpected port (connection=%fd.name)"
+#   priority: WARNING
+
+# Gearman ports
+# http://gearman.org/protocol/
+# - rule: Gearman unexpected network outbound traffic
+#   desc: outbound network traffic from gearman on a port other than the standard ports
+#   condition: user.name = gearman and outbound and outbound and not fd.sport = 4730
+#   output: "Outbound network traffic from Gearman on unexpected port (connection=%fd.name)"
+#   priority: WARNING
+
+# Zookeeper
+- macro: zookeeper_port
+  condition: fd.sport = 2181
+
+# Kafka ports
+# - rule: Kafka unexpected network inbound traffic
+#   desc: inbound network traffic to kafka on a port other than the standard ports
+#   condition: user.name = kafka and inbound and fd.sport != 9092
+#   output: "Inbound network traffic to Kafka on unexpected port (connection=%fd.name)"
+#   priority: WARNING
+
+# Memcached ports
+# - rule: Memcached unexpected network inbound traffic
+#   desc: inbound network traffic to memcached on a port other than the standard ports
+#   condition: user.name = memcached and inbound and fd.sport != 11211
+#   output: "Inbound network traffic to Memcached on unexpected port (connection=%fd.name)"
+#   priority: WARNING
+
+# - rule: Memcached unexpected network outbound traffic
+#   desc: any outbound network traffic from memcached. memcached never initiates outbound connections.
+#   condition: user.name = memcached and outbound
+#   output: "Unexpected Memcached outbound connection (connection=%fd.name)"
+#   priority: WARNING
+
+
+# MongoDB ports
+- macro: mongodb_server_port
+  condition: fd.sport = 27017
+- macro: mongodb_shardserver_port
+  condition: fd.sport = 27018
+- macro: mongodb_configserver_port
+  condition: fd.sport = 27019
+- macro: mongodb_webserver_port
+  condition: fd.sport = 28017
+
+# - rule: Mongodb unexpected network inbound traffic
+#   desc: inbound network traffic to mongodb on a port other than the standard ports
+#   condition: >
+#     user.name = mongodb and inbound and not (mongodb_server_port or
+#     mongodb_shardserver_port or mongodb_configserver_port or mongodb_webserver_port)
+#   output: "Inbound network traffic to MongoDB on unexpected port (connection=%fd.name)"
+#   priority: WARNING
+
+# MySQL ports
+# - rule: Mysql unexpected network inbound traffic
+#   desc: inbound network traffic to mysql on a port other than the standard ports
+#   condition: user.name = mysql and inbound and fd.sport != 3306
+#   output: "Inbound network traffic to MySQL on unexpected port (connection=%fd.name)"
+#   priority: WARNING
+
+# - rule: HTTP server unexpected network inbound traffic
+#   desc: inbound network traffic to a http server program on a port other than the standard ports
+#   condition: proc.name in (http_server_binaries) and inbound and fd.sport != 80 and fd.sport != 443
+#   output: "Inbound network traffic to HTTP Server on unexpected port (connection=%fd.name)"
+#   priority: WARNING
--- a/rules/falco_rules.local.yaml
+++ b/rules/falco_rules.local.yaml
@@ -0,0 +1,30 @@
+#
+# Copyright (C) 2019 The Falco Authors.
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+####################
+# Your custom rules!
+####################
+
+# Add new rules, like this one
+# - rule: The program "sudo" is run in a container
+#   desc: An event will trigger every time you run sudo in a container
+#   condition: evt.type = execve and evt.dir=< and container.id != host and proc.name = sudo
+#   output: "Sudo run in container (user=%user.name %container.info parent=%proc.pname cmdline=%proc.cmdline)"
+#   priority: ERROR
+#   tags: [users, container]
+
+# Or override/append to any rule, macro, or list from the Default Rules
--- a/rules/falco_rules.yaml
+++ b/rules/falco_rules.yaml
--- a/scripts/CMakeLists.txt
+++ b/scripts/CMakeLists.txt
@@ -15,39 +15,28 @@
 # limitations under the License.
 #

-# Systemd
-file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/scripts/systemd)
-configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falco-kmod-inject.service"
-		"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
-configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falco-kmod.service"
-		"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
-configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falco-bpf.service"
-		"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
-configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falco-modern-bpf.service"
-		"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
-configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falco-custom.service"
-		"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
-configure_file("${PROJECT_SOURCE_DIR}/scripts/systemd/falcoctl-artifact-follow.service"
-		"${PROJECT_BINARY_DIR}/scripts/systemd" COPYONLY)
+configure_file(debian/postinst.in debian/postinst)
+configure_file(debian/postrm.in debian/postrm)
+configure_file(debian/prerm.in debian/prerm)

-# Debian
-configure_file(debian/postinst.in debian/postinst COPYONLY)
-configure_file(debian/postrm.in debian/postrm COPYONLY)
-configure_file(debian/prerm.in debian/prerm COPYONLY)
+file(COPY "${PROJECT_SOURCE_DIR}/scripts/debian/falco.service"
+	DESTINATION "${PROJECT_BINARY_DIR}/scripts/debian")

-# Rpm
-configure_file(rpm/postinstall.in rpm/postinstall COPYONLY)
-configure_file(rpm/postuninstall.in rpm/postuninstall COPYONLY)
-configure_file(rpm/preuninstall.in rpm/preuninstall COPYONLY)
+file(COPY "${PROJECT_SOURCE_DIR}/scripts/debian/falco_inject_kmod.service"
+	DESTINATION "${PROJECT_BINARY_DIR}/scripts/debian")
+
+configure_file(rpm/postinstall.in rpm/postinstall)
+configure_file(rpm/postuninstall.in rpm/postuninstall)
+configure_file(rpm/preuninstall.in rpm/preuninstall)
+
+file(COPY "${PROJECT_SOURCE_DIR}/scripts/rpm/falco.service"
+	DESTINATION "${PROJECT_BINARY_DIR}/scripts/rpm")
+
+file(COPY "${PROJECT_SOURCE_DIR}/scripts/rpm/falco_inject_kmod.service"
+	DESTINATION "${PROJECT_BINARY_DIR}/scripts/rpm")

 configure_file(falco-driver-loader falco-driver-loader @ONLY)

-# Install Falcoctl config file
-if(NOT DEFINED FALCOCTL_ETC_DIR)
-	set(FALCOCTL_ETC_DIR "${CMAKE_INSTALL_FULL_SYSCONFDIR}/falcoctl")
-endif()
-install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/falcoctl/falcoctl.yaml DESTINATION "${FALCOCTL_ETC_DIR}" COMPONENT "${FALCO_COMPONENT_NAME}")
-
 if(CMAKE_SYSTEM_NAME MATCHES "Linux")
 	install(PROGRAMS ${PROJECT_BINARY_DIR}/scripts/falco-driver-loader
 		DESTINATION ${FALCO_BIN_DIR} COMPONENT "${FALCO_COMPONENT_NAME}")
--- a/scripts/systemd/falco-custom.service
+++ b/scripts/systemd/falco-custom.service
@@ -1,13 +1,14 @@
 [Unit]
-Description=Falco: Container Native Runtime Security with custom configuration
+Description=Falco: Container Native Runtime Security
 Documentation=https://falco.org/docs/
-Before=falcoctl-artifact-follow.service
-Wants=falcoctl-artifact-follow.service
+After=falco_inject_kmod.service
+Requires=falco_inject_kmod.service

 [Service]
 Type=simple
-User=%u
+User=root
 ExecStart=/usr/bin/falco --pidfile=/var/run/falco.pid
+ExecStopPost=/sbin/rmmod falco
 UMask=0077
 TimeoutSec=30
 RestartSec=15s
@@ -17,9 +18,9 @@ NoNewPrivileges=yes
 ProtectHome=read-only
 ProtectSystem=full
 ProtectKernelTunables=true
+ReadWritePaths=/sys/module/falco
 RestrictRealtime=true
 RestrictAddressFamilies=~AF_PACKET
-StandardOutput=null

 [Install]
 WantedBy=multi-user.target
--- a/scripts/debian/falco_inject_kmod.service
+++ b/scripts/debian/falco_inject_kmod.service
@@ -0,0 +1,13 @@
+[Unit]
+Description=Falco: Container Native Runtime Security
+Documentation=https://falco.org/docs/
+Before=falco.service
+Wants=falco.service
+
+[Service]
+Type=oneshot
+User=root
+ExecStart=/sbin/modprobe falco
+
+[Install]
+WantedBy=multi-user.target
--- a/scripts/debian/postinst.in
+++ b/scripts/debian/postinst.in
@@ -15,85 +15,60 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
-chosen_driver=
-
-# Every time we call this script we want to stat from a clean state.
-echo "[POST-INSTALL] Disable all possible 'falco' services:"
-systemctl --system stop 'falco-kmod.service' || true
-systemctl --system stop 'falco-bpf.service' || true
-systemctl --system stop 'falco-modern-bpf.service' || true
-systemctl --system stop 'falco-custom.service' || true
-systemctl --system stop 'falcoctl-artifact-follow.service' || true
-systemctl --system disable 'falco-kmod.service' || true
-systemctl --system disable 'falco-bpf.service' || true
-systemctl --system disable 'falco-modern-bpf.service' || true
-systemctl --system disable 'falco-custom.service' || true
-systemctl --system disable 'falcoctl-artifact-follow.service' || true
-
-# unmask falcoctl if it was masked
-systemctl --system unmask falcoctl-artifact-follow.service || true
-
-if [ "$1" = "configure" ]; then
-        if [ -x /usr/bin/dialog ] && [ "${FALCO_FRONTEND}" != "noninteractive" ]; then
-          # If dialog is installed, create a dialog to let users choose the correct driver for them
-          CHOICE=$(dialog --clear --title "Falco drivers" --menu "Choose your preferred driver:" 12 55 4 \
-                1 "Manual configuration (no unit is started)" \
-                2 "Kmod" \
-                3 "eBPF" \
-                4 "Modern eBPF" \
-                2>&1 >/dev/tty)
-          case $CHOICE in
-                  2)
-                      chosen_driver="kmod"
-                      ;;
-                  3)
-                      chosen_driver="bpf"
-                      ;;
-                  4)
-                      chosen_driver="modern-bpf"
-                      ;;
-          esac
-          if [ -n "$chosen_driver" ]; then
-            CHOICE=$(dialog --clear --title "Falcoctl" --menu "Do you want to follow automatic ruleset updates?" 10 40 2 \
-                    1 "Yes" \
-                    2 "No" \
-                    2>&1 >/dev/tty)
-            case $CHOICE in
-                2)
-                # we don't want falcoctl enabled, we mask it
-                systemctl --system mask falcoctl-artifact-follow.service || true
-                ;;
-            esac
-          fi
-          clear
-        fi
-fi
-
 set -e

-echo "[POST-INSTALL] Trigger deamon-reload:"
-systemctl --system daemon-reload || true
+DKMS_PACKAGE_NAME="@PACKAGE_NAME@"
+DKMS_VERSION="@DRIVER_VERSION@"
+NAME="@PACKAGE_NAME@"

-# If needed, try to load/compile the driver through falco-driver-loader
-case "$chosen_driver" in
-    "kmod")
-      # Only compile for kmod, in this way we use dkms
-      echo "[POST-INSTALL] Call 'falco-driver-loader --compile module':"
-      falco-driver-loader --compile module
-      ;;
-    "bpf")
-      echo "[POST-INSTALL] Call 'falco-driver-loader bpf':"
-      falco-driver-loader bpf
-      ;;
+postinst_found=0
+
+case "$1" in
+	configure)
+		for DKMS_POSTINST in /usr/lib/dkms/common.postinst /usr/share/$DKMS_PACKAGE_NAME/postinst; do
+			if [ -f $DKMS_POSTINST ]; then
+				$DKMS_POSTINST $DKMS_PACKAGE_NAME $DKMS_VERSION /usr/share/$DKMS_PACKAGE_NAME "" $2
+				postinst_found=1
+				break
+			fi
+		done
+		if [ "$postinst_found" -eq 0 ]; then
+			echo "ERROR: DKMS version is too old and $DKMS_PACKAGE_NAME was not"
+			echo "built with legacy DKMS support."
+			echo "You must either rebuild $DKMS_PACKAGE_NAME with legacy postinst"
+			echo "support or upgrade DKMS to a more current version."
+			exit 1
+		fi
+	;;
 esac

+# Based off what debhelper dh_systemd_enable/13.3.4 would have added
+# ref: https://www.debian.org/doc/manuals/debmake-doc/ch05.en.html#debhelper
+
 if [ "$1" = "configure" ] || [ "$1" = "abort-upgrade" ] || [ "$1" = "abort-deconfigure" ] || [ "$1" = "abort-remove" ] ; then
-        if [ -n "$chosen_driver" ]; then
-            # we do this in 2 steps because `enable --now` is not always supported
-            echo "[POST-INSTALL] Enable 'falco-$chosen_driver.service':"
-            systemctl --system enable "falco-$chosen_driver.service" || true
-            echo "[POST-INSTALL] Start 'falco-$chosen_driver.service':"
-            systemctl --system start "falco-$chosen_driver.service" || true           
+        # This will only remove masks created by d-s-h on package removal.
+        deb-systemd-helper unmask 'falco.service' >/dev/null || true
+
+        # was-enabled defaults to true, so new installations run enable.
+        if deb-systemd-helper --quiet was-enabled 'falco.service'; then
+                # Enables the unit on first installation, creates new
+                # symlinks on upgrades if the unit file has changed.
+                deb-systemd-helper enable 'falco.service' >/dev/null || true
+        else
+                # Update the statefile to add new symlinks (if any), which need to be
+                # cleaned up on purge. Also remove old symlinks.
+                deb-systemd-helper update-state 'falco.service' >/dev/null || true
+        fi
+fi
+
+if [ "$1" = "configure" ] || [ "$1" = "abort-upgrade" ] || [ "$1" = "abort-deconfigure" ] || [ "$1" = "abort-remove" ] ; then
+        if [ -d /run/systemd/system ]; then
+                systemctl --system daemon-reload >/dev/null || true
+                if [ -n "$2" ]; then
+                        _dh_action=restart
+                else
+                        _dh_action=start
+                fi
+                deb-systemd-invoke $_dh_action 'falco.service' >/dev/null || true
        fi
 fi
--- a/scripts/debian/postrm.in
+++ b/scripts/debian/postrm.in
@@ -22,13 +22,18 @@
 set -e

 if [ -d /run/systemd/system ] && [ "$1" = remove ]; then
-        echo "[POST-REMOVE] Disable all Falco services:"
-        systemctl --system disable 'falco-kmod.service' || true
-        systemctl --system disable 'falco-bpf.service' || true
-        systemctl --system disable 'falco-modern-bpf.service' || true
-        systemctl --system disable 'falco-custom.service' || true
-        systemctl --system disable 'falcoctl-artifact-follow.service' || true
-
-        echo "[POST-REMOVE] Trigger deamon-reload:"
-        systemctl --system daemon-reload || true
+        systemctl --system daemon-reload >/dev/null || true
+fi
+
+if [ "$1" = "remove" ]; then
+        if [ -x "/usr/bin/deb-systemd-helper" ]; then
+                deb-systemd-helper mask 'falco.service' >/dev/null || true
+        fi
+fi
+
+if [ "$1" = "purge" ]; then
+        if [ -x "/usr/bin/deb-systemd-helper" ]; then
+                deb-systemd-helper purge 'falco.service' >/dev/null || true
+                deb-systemd-helper unmask 'falco.service' >/dev/null || true
+        fi
 fi
--- a/scripts/debian/prerm.in
+++ b/scripts/debian/prerm.in
@@ -21,16 +21,12 @@ set -e
 # ref: https://www.debian.org/doc/manuals/debmake-doc/ch05.en.html#debhelper
 # Currently running falco service uses the driver, so stop it before driver cleanup

-case "$1" in
-    remove|upgrade|deconfigure)
-      echo "[PRE-REMOVE] Stop all Falco services:"
-      systemctl --system stop 'falco-kmod.service' || true
-      systemctl --system stop 'falco-bpf.service' || true
-      systemctl --system stop 'falco-modern-bpf.service' || true
-      systemctl --system stop 'falco-custom.service' || true
-      systemctl --system stop 'falcoctl-artifact-follow.service' || true
+if [ -d /run/systemd/system ] && [ "$1" = remove ]; then
+        deb-systemd-invoke stop 'falco.service' >/dev/null || true
+fi

-      echo "[PRE-REMOVE] Call 'falco-driver-loader --clean:'"
-      falco-driver-loader --clean
-    ;;
+case "$1" in
+	remove|upgrade|deconfigure)
+		/usr/bin/falco-driver-loader --clean
+	;;
 esac
--- a/scripts/falco-driver-loader
+++ b/scripts/falco-driver-loader
@@ -113,9 +113,6 @@ get_target_id() {
 	elif [ -f "${HOST_ROOT}/etc/centos-release" ]; then
 		# Older CentOS distros
 		OS_ID=centos
-	elif [ -f "${HOST_ROOT}/etc/redhat-release" ]; then
-		# Older RHEL distros
-		OS_ID=rhel
 	else
 		return 1
 	fi
@@ -128,38 +125,10 @@ get_target_id() {

 	case "${OS_ID}" in
 	("amzn")
-		case "${VERSION_ID}" in
-		("2")
+		if [[ $VERSION_ID == "2" ]]; then
 			TARGET_ID="amazonlinux2"
-			;;
-		("2022")
-			TARGET_ID="amazonlinux2022"
-			;;
-		("2023")
-			TARGET_ID="amazonlinux2023"
-			;;
-		(*)
+		else
 			TARGET_ID="amazonlinux"
-			;;
-		esac
-		;;
-	("debian")
-		# Workaround: debian kernelreleases might now be actual kernel running;
-		# instead, they might be the Debian kernel package
-		# providing the compatible kernel ABI
-		# See https://lists.debian.org/debian-user/2017/03/msg00485.html
-		# Real kernel release is embedded inside the kernel version.
-		# Moreover, kernel arch, when present, is attached to the former,
-		# therefore make sure to properly take it and attach it to the latter.
-		TARGET_ID=$(echo "${OS_ID}" | tr '[:upper:]' '[:lower:]')
-		local ARCH_extra=""
-		if [[ $KERNEL_RELEASE =~ -(amd64|arm64) ]];
-		then
-			ARCH_extra="-${BASH_REMATCH[1]}"
-		fi
-		if [[ $(uname -v) =~ ([0-9]+\.[0-9]+\.[0-9]+\-[0-9]+) ]];
-		then
-			KERNEL_RELEASE="${BASH_REMATCH[1]}${ARCH_extra}"
 		fi
 		;;
 	("ubuntu")
@@ -179,7 +148,7 @@ get_target_id() {
 		TARGET_ID=$(echo "${OS_ID}" | tr '[:upper:]' '[:lower:]')
 		;;
 	("minikube")
-		TARGET_ID=$(echo "${OS_ID}" | tr '[:upper:]' '[:lower:]')
+		TARGET_ID="${OS_ID}"
 		# Extract the minikube version. Ex. With minikube version equal to "v1.26.0-1655407986-14197" the extracted version
 		# will be "1.26.0"
 		if [[ $(cat ${HOST_ROOT}/etc/VERSION) =~ ([0-9]+(\.[0-9]+){2}) ]]; then
@@ -190,21 +159,6 @@ get_target_id() {
 			exit 1
 		fi
 		;;
-	("bottlerocket")
-		TARGET_ID=$(echo "${OS_ID}" | tr '[:upper:]' '[:lower:]')
-		# variant_id has been sourced from os-release. Get only the first variant part
-		if [[ -n ${VARIANT_ID} ]];  then
-			# take just first part (eg: VARIANT_ID=aws-k8s-1.15 -> aws)
-			VARIANT_ID_CUT=${VARIANT_ID%%-*}
-		fi
-		# version_id has been sourced from os-release. Build a kernel version like: 1_1.11.0-aws
-		KERNEL_VERSION="1_${VERSION_ID}-${VARIANT_ID_CUT}"
-		;;
-	("talos")
-		TARGET_ID=$(echo "${OS_ID}" | tr '[:upper:]' '[:lower:]')
-		# version_id has been sourced from os-release. Build a kernel version like: 1_1.4.1
-		KERNEL_VERSION="1_${VERSION_ID}"
-		;;
 	(*)
 		TARGET_ID=$(echo "${OS_ID}" | tr '[:upper:]' '[:lower:]')
 		;;
@@ -257,18 +211,12 @@ load_kernel_module_compile() {
 	fi

 	# Try to compile using all the available gcc versions
-	for CURRENT_GCC in $(ls "$(dirname "$(which gcc)")"/gcc*); do
-		# Filter away gcc-{ar,nm,...}
-		# Only gcc compiler has `-print-search-dirs` option.
-		${CURRENT_GCC} -print-search-dirs 2>&1 | grep "install:"
-		if [ "$?" -ne "0" ]; then
-			continue
-		fi
+	for CURRENT_GCC in $(which gcc) $(ls "$(dirname "$(which gcc)")"/gcc-* | grep 'gcc-[0-9]\+' | sort -n -r -k 2 -t -); do
 		echo "* Trying to dkms install ${DRIVER_NAME} module with GCC ${CURRENT_GCC}"
-		echo "#!/usr/bin/env bash" > "${TMPDIR}/falco-dkms-make"
-		echo "make CC=${CURRENT_GCC} \$@" >> "${TMPDIR}/falco-dkms-make"
-		chmod +x "${TMPDIR}/falco-dkms-make"
-		if dkms install --directive="MAKE='${TMPDIR}/falco-dkms-make'" -m "${DRIVER_NAME}" -v "${DRIVER_VERSION}" -k "${KERNEL_RELEASE}" 2>/dev/null; then
+		echo "#!/usr/bin/env bash" > /tmp/falco-dkms-make
+		echo "make CC=${CURRENT_GCC} \$@" >> /tmp/falco-dkms-make
+		chmod +x /tmp/falco-dkms-make
+		if dkms install --directive="MAKE='/tmp/falco-dkms-make'" -m "${DRIVER_NAME}" -v "${DRIVER_VERSION}" -k "${KERNEL_RELEASE}" 2>/dev/null; then
 			echo "* ${DRIVER_NAME} module installed in dkms"
 			KO_FILE="/var/lib/dkms/${DRIVER_NAME}/${DRIVER_VERSION}/${KERNEL_RELEASE}/${ARCH}/module/${DRIVER_NAME}"
 			if [ -f "$KO_FILE.ko" ]; then
@@ -284,13 +232,14 @@ load_kernel_module_compile() {
 				return
 			fi
 			echo "* ${DRIVER_NAME} module found: ${KO_FILE}"
-			echo "* Trying to insmod"
+			echo "* Trying insmod"
 			chcon -t modules_object_t "$KO_FILE" > /dev/null 2>&1 || true
 			if insmod "$KO_FILE" > /dev/null 2>&1; then
 				echo "* Success: ${DRIVER_NAME} module found and loaded in dkms"
 				exit 0
+			else
+				echo "* Unable to insmod ${DRIVER_NAME} module"
 			fi
-			echo "* Unable to insmod ${DRIVER_NAME} module"
 		else
 			DKMS_LOG="/var/lib/dkms/${DRIVER_NAME}/${DRIVER_VERSION}/build/make.log"
 			if [ -f "${DKMS_LOG}" ]; then
@@ -308,14 +257,15 @@ load_kernel_module_download() {
 	local URL=$(echo "${1}/${DRIVER_VERSION}/${ARCH}/${FALCO_KERNEL_MODULE_FILENAME}" | sed s/+/%2B/g)

 	echo "* Trying to download a prebuilt ${DRIVER_NAME} module from ${URL}"
-	if curl -L --create-dirs ${FALCO_DRIVER_CURL_OPTIONS} -o "${HOME}/.falco/${DRIVER_VERSION}/${ARCH}/${FALCO_KERNEL_MODULE_FILENAME}" "${URL}"; then
+	if curl -L --create-dirs "${FALCO_DRIVER_CURL_OPTIONS}" -o "${HOME}/.falco/${DRIVER_VERSION}/${ARCH}/${FALCO_KERNEL_MODULE_FILENAME}" "${URL}"; then
 		echo "* Download succeeded"
 		chcon -t modules_object_t "${HOME}/.falco/${DRIVER_VERSION}/${ARCH}/${FALCO_KERNEL_MODULE_FILENAME}" > /dev/null 2>&1 || true
 		if insmod "${HOME}/.falco/${DRIVER_VERSION}/${ARCH}/${FALCO_KERNEL_MODULE_FILENAME}"; then
 			echo "* Success: ${DRIVER_NAME} module found and inserted"
 			exit 0
-		fi
-		>&2 echo "Unable to insmod the prebuilt ${DRIVER_NAME} module"
+		else
+			>&2 echo "Unable to insmod the prebuilt ${DRIVER_NAME} module"
+		fi	
 	else
 		>&2 echo "Unable to find a prebuilt ${DRIVER_NAME} module"
 		return
@@ -534,7 +484,7 @@ load_bpf_probe_compile() {
 		mkdir -p /tmp/kernel
 		cd /tmp/kernel || exit
 		cd "$(mktemp -d -p /tmp/kernel)" || exit
-		if ! curl -L -o kernel-sources.tgz --create-dirs ${FALCO_DRIVER_CURL_OPTIONS} "${BPF_KERNEL_SOURCES_URL}"; then
+		if ! curl -L -o kernel-sources.tgz --create-dirs "${FALCO_DRIVER_CURL_OPTIONS}" "${BPF_KERNEL_SOURCES_URL}"; then
 			>&2 echo "Unable to download the kernel sources"
 			return
 		fi
@@ -576,7 +526,7 @@ load_bpf_probe_download() {

 	echo "* Trying to download a prebuilt eBPF probe from ${URL}"

-	if ! curl -L --create-dirs ${FALCO_DRIVER_CURL_OPTIONS} -o "${HOME}/.falco/${DRIVER_VERSION}/${ARCH}/${BPF_PROBE_FILENAME}" "${URL}"; then
+	if ! curl -L --create-dirs "${FALCO_DRIVER_CURL_OPTIONS}" -o "${HOME}/.falco/${DRIVER_VERSION}/${ARCH}/${BPF_PROBE_FILENAME}" "${URL}"; then
 		>&2 echo "Unable to find a prebuilt ${DRIVER_NAME} eBPF probe"
 		return 1
 	fi
@@ -648,7 +598,6 @@ print_usage() {
 	echo "  DRIVERS_REPO             specify different URL(s) where to look for prebuilt Falco drivers (comma separated)"
 	echo "  DRIVER_NAME              specify a different name for the driver"
 	echo "  DRIVER_INSECURE_DOWNLOAD whether you want to allow insecure downloads or not"
-	echo "  DRIVER_CURL_OPTIONS      specify additional options to be passed to curl command used to download Falco drivers"
 	echo ""
 	echo "Versions:"
 	echo "  Falco version  ${FALCO_VERSION}"
@@ -668,15 +617,13 @@ KERNEL_VERSION=$(uname -v | sed 's/#\([[:digit:]]\+\).*/\1/')

 DRIVERS_REPO=${DRIVERS_REPO:-"@DRIVERS_REPO@"}

-FALCO_DRIVER_CURL_OPTIONS="-fsS --connect-timeout 5 --max-time 60 --retry 3 --retry-max-time 120"
-
 if [ -n "$DRIVER_INSECURE_DOWNLOAD" ]
 then
-	FALCO_DRIVER_CURL_OPTIONS+=" -k"
+	FALCO_DRIVER_CURL_OPTIONS=-fsSk
+else
+	FALCO_DRIVER_CURL_OPTIONS=-fsS
 fi

-FALCO_DRIVER_CURL_OPTIONS+=" "${DRIVER_CURL_OPTIONS}
-
 if [[ -z "$MAX_RMMOD_WAIT" ]]; then
 	MAX_RMMOD_WAIT=60
 fi
@@ -692,8 +639,6 @@ if [ -v FALCO_BPF_PROBE ]; then
 	DRIVER="bpf"
 fi

-TMPDIR=${TMPDIR:-"/tmp"}
-
 ENABLE_COMPILE=
 ENABLE_DOWNLOAD=

--- a/scripts/falcoctl/falcoctl.yaml
+++ b/scripts/falcoctl/falcoctl.yaml
@@ -1,9 +0,0 @@
-artifact:
-  follow:
-    every: 6h0m0s
-    falcoVersions: http://localhost:8765/versions
-    refs:
-    - falco-rules:0
-indexes:
- name: falcosecurity
-  url: https://falcosecurity.github.io/falcoctl/index.yaml
--- a/scripts/publish-deb
+++ b/scripts/publish-deb
@@ -2,7 +2,7 @@
 set -e

 usage() {
-    echo "usage: $0 -f <package_x86_64.deb> -f <package_aarch64.deb> -r <deb|deb-dev> [-s]"
+    echo "usage: $0 -f <package_x86_64.deb> -f <package_aarch64.deb> -r <deb|deb-dev>"
    exit 1
 }

@@ -21,18 +21,6 @@ join_arr() {
  echo "$*"
 }

-# Updates the signature of a DEB package in the local repository
-#
-# $1: path of the repository.
-# $2: suite (eg. "stable")
-# $3: path of the DEB file.
-sign_deb() {
-    pushd $1/$2 > /dev/null
-    rm -f $(basename -- $3).asc
-    gpg --detach-sign --digest-algo SHA256 --armor $(basename -- $3)
-    popd > /dev/null
-}
-
 # Add a package to the local DEB repository
 #
 # $1: path of the repository.
@@ -40,7 +28,10 @@ sign_deb() {
 # $3: path of the DEB file.
 add_deb() {
    cp -f $3 $1/$2
-    sign_deb $1 $2 $3
+    pushd $1/$2 > /dev/null
+    rm -f $(basename -- $3).asc
+    gpg --detach-sign --digest-algo SHA256 --armor $(basename -- $3)
+    popd > /dev/null

    # Get package architecture from dpkg
    local arch=$(dpkg --info $3 |  awk '/Architecture/ {printf "%s", $2}')
@@ -63,27 +54,6 @@ falco_arch_from_deb_arch() {
    esac  
 }

-# Sign the local DEB repository
-#
-# $1: path of the repository
-# $2: suite (eg. "stable")
-sign_repo() {
-    local release_dir=dists/$2
-    pushd $1 > /dev/null
-
-    # release signature - Release.gpg file
-    gpg --detach-sign --digest-algo SHA256 --armor ${release_dir}/Release
-    rm -f ${release_dir}/Release.gpg
-    mv ${release_dir}/Release.asc ${release_dir}/Release.gpg
-    
-    # release signature - InRelease file
-    gpg --armor --sign --clearsign --digest-algo SHA256 ${release_dir}/Release
-    rm -f ${release_dir}/InRelease
-    mv ${release_dir}/Release.asc ${release_dir}/InRelease
-
-    popd > /dev/null
-}
-
 # Update the local DEB repository
 #
 # $1: path of the repository
@@ -118,11 +88,21 @@ update_repo() {
      -o APT::FTPArchive::Release::Architectures="$(join_arr , "${architectures[@]}")" \
      ${release_dir} > ${release_dir}/Release

+    # release signature - Release.gpg file
+    gpg --detach-sign --digest-algo SHA256 --armor ${release_dir}/Release
+    rm -f ${release_dir}/Release.gpg
+    mv ${release_dir}/Release.asc ${release_dir}/Release.gpg
+    
+    # release signature - InRelease file
+    gpg --armor --sign --clearsign --digest-algo SHA256 ${release_dir}/Release
+    rm -f ${release_dir}/InRelease
+    mv ${release_dir}/Release.asc ${release_dir}/InRelease
+
    popd > /dev/null
 }

 # parse options
-while getopts ":f::r::s" opt; do
+while getopts ":f::r:" opt; do
    case "${opt}" in
        f )
          files+=("${OPTARG}")
@@ -131,9 +111,6 @@ while getopts ":f::r::s" opt; do
          repo="${OPTARG}"
          [[ "${repo}" == "deb" || "${repo}" == "deb-dev" ]] || usage
          ;;
-        s )
-          sign_all="true"
-          ;;
        : )
          echo "invalid option: ${OPTARG} requires an argument" 1>&2
          exit 1
@@ -147,7 +124,7 @@ done
 shift $((OPTIND-1))

 # check options
-if ([ ${#files[@]} -eq 0 ] && [ -z "${sign_all}" ]) || [ -z "${repo}" ]; then
+if [ ${#files[@]} -eq 0 ] || [ -z "${repo}" ]; then
    usage
 fi

@@ -170,45 +147,24 @@ echo "Fetching ${s3_bucket_repo}..."
 mkdir -p ${tmp_repo_path}
 aws s3 cp ${s3_bucket_repo} ${tmp_repo_path} --recursive

-# update signatures for all existing packages
-if [ "${sign_all}" ]; then
-  for file in ${tmp_repo_path}/${debSuite}/*; do
-    if [ -f "$file" ]; then # exclude directories, symlinks, etc...
-      if [[ ! $file == *.asc ]]; then # exclude signature files
-        package=$(basename -- ${file})
-        echo "Signing ${package}..."
-        sign_deb ${tmp_repo_path} ${debSuite} ${file}
+# update the repo
+for file in "${files[@]}"; do
+  echo "Adding ${file}..."
+  add_deb ${tmp_repo_path} ${debSuite} ${file}
+done
+update_repo ${tmp_repo_path} ${debSuite}

-        echo "Syncing ${package}.asc to ${s3_bucket_repo}..."
-        aws s3 cp ${tmp_repo_path}/${debSuite}/${package}.asc ${s3_bucket_repo}/${debSuite}/${package}.asc --acl public-read
-      fi
-    fi
-  done
-  aws cloudfront create-invalidation --distribution-id ${AWS_CLOUDFRONT_DIST_ID} --paths ${cloudfront_path}/${debSuite}/*.asc
-  sign_repo ${tmp_repo_path} ${debSuite}
-fi
+# publish
+for file in "${files[@]}"; do
+  package=$(basename -- ${file})
+  echo "Publishing ${package} to ${s3_bucket_repo}..."
+  aws s3 cp ${tmp_repo_path}/${debSuite}/${package} ${s3_bucket_repo}/${debSuite}/${package} --acl public-read
+  aws s3 cp ${tmp_repo_path}/${debSuite}/${package}.asc ${s3_bucket_repo}/${debSuite}/${package}.asc --acl public-read

-# update the repo by adding new packages
-if ! [ ${#files[@]} -eq 0 ]; then
-  for file in "${files[@]}"; do
-    echo "Adding ${file}..."
-    add_deb ${tmp_repo_path} ${debSuite} ${file}
-  done
-  update_repo ${tmp_repo_path} ${debSuite}
-  sign_repo ${tmp_repo_path} ${debSuite}
-
-  # publish
-  for file in "${files[@]}"; do
-    package=$(basename -- ${file})
-    echo "Publishing ${package} to ${s3_bucket_repo}..."
-    aws s3 cp ${tmp_repo_path}/${debSuite}/${package} ${s3_bucket_repo}/${debSuite}/${package} --acl public-read
-    aws s3 cp ${tmp_repo_path}/${debSuite}/${package}.asc ${s3_bucket_repo}/${debSuite}/${package}.asc --acl public-read
-
-    aws cloudfront create-invalidation --distribution-id ${AWS_CLOUDFRONT_DIST_ID} --paths ${cloudfront_path}/${debSuite}/${package}
-    aws cloudfront create-invalidation --distribution-id ${AWS_CLOUDFRONT_DIST_ID} --paths ${cloudfront_path}/${debSuite}/${package}.asc
-  done
-fi
+  aws cloudfront create-invalidation --distribution-id ${AWS_CLOUDFRONT_DIST_ID} --paths ${cloudfront_path}/${debSuite}/${package}
+  aws cloudfront create-invalidation --distribution-id ${AWS_CLOUDFRONT_DIST_ID} --paths ${cloudfront_path}/${debSuite}/${package}.asc
+done

 # sync dists
 aws s3 sync ${tmp_repo_path}/dists ${s3_bucket_repo}/dists --delete --acl public-read
-aws cloudfront create-invalidation --distribution-id ${AWS_CLOUDFRONT_DIST_ID} --paths ${cloudfront_path}/dists/*
+aws cloudfront create-invalidation --distribution-id ${AWS_CLOUDFRONT_DIST_ID} --paths ${cloudfront_path}/dists/*
--- a/scripts/publish-rpm
+++ b/scripts/publish-rpm
@@ -2,7 +2,7 @@
 set -e

 usage() {
-    echo "usage: $0 -f <package_x86_64.rpm> -f <package_aarch64.rpm> -r <rpm|rpm-dev> [-s]"
+    echo "usage: $0 -f <package_x86_64.rpm> -f <package_aarch64.rpm> -r <rpm|rpm-dev>"
    exit 1
 }

@@ -14,33 +14,15 @@ check_program() {
  fi
 }

-# Updates the signature of a RPM package in the local repository
-#
-# $1: path of the repository.
-# $2: path of the RPM file.
-sign_rpm() {
-    pushd $1 > /dev/null
-    rm -f $(basename -- $2).asc
-    gpg --detach-sign --digest-algo SHA256 --armor $(basename -- $2)
-    popd > /dev/null
-}
-
 # Add a package to the local RPM repository
 #
 # $1: path of the repository.
 # $2: path of the RPM file.
 add_rpm() {
    cp -f $2 $1
-    sign_rpm $1 $2
-}
-
-# Sign the local RPM repository
-#
-# $1: path of the repository.
-sign_repo() {
    pushd $1 > /dev/null
-    rm -f repodata/repomd.xml.asc
-    gpg --detach-sign --digest-algo SHA256 --armor repodata/repomd.xml
+    rm -f $(basename -- $2).asc
+    gpg --detach-sign --digest-algo SHA256 --armor $(basename -- $2)
    popd > /dev/null
 }

@@ -50,11 +32,14 @@ sign_repo() {
 update_repo() {
    pushd $1 > /dev/null
    createrepo --update --no-database .
+    rm -f repodata/repomd.xml.asc
+    gpg --detach-sign --digest-algo SHA256 --armor repodata/repomd.xml
    popd > /dev/null
 }

+
 # parse options
-while getopts ":f::r::s" opt; do
+while getopts ":f::r:" opt; do
    case "${opt}" in
        f )
          files+=("${OPTARG}")
@@ -63,9 +48,6 @@ while getopts ":f::r::s" opt; do
          repo="${OPTARG}"
          [[ "${repo}" == "rpm" || "${repo}" == "rpm-dev" ]] || usage
          ;;
-        s )
-          sign_all="true"
-          ;;
        : )
          echo "invalid option: ${OPTARG} requires an argument" 1>&2
          exit 1
@@ -78,7 +60,7 @@ while getopts ":f::r::s" opt; do
 done
 shift $((OPTIND-1))

-if ([ ${#files[@]} -eq 0 ] && [ -z "${sign_all}" ]) || [ -z "${repo}" ]; then
+if [ ${#files[@]} -eq 0 ] || [ -z "${repo}" ]; then
    usage
 fi

@@ -97,45 +79,24 @@ echo "Fetching ${s3_bucket_repo}..."
 mkdir -p ${tmp_repo_path}
 aws s3 cp ${s3_bucket_repo} ${tmp_repo_path} --recursive

-# update signatures for all existing packages
-if [ "${sign_all}" ]; then
-  for file in ${tmp_repo_path}/*; do
-    if [ -f "$file" ]; then # exclude directories, symlinks, etc...
-      if [[ ! $file == *.asc ]]; then # exclude signature files
-        package=$(basename -- ${file})
-        echo "Signing ${package}..."
-        sign_rpm ${tmp_repo_path} ${file}
+# update the repo
+for file in "${files[@]}"; do
+  echo "Adding ${file}..."
+  add_rpm ${tmp_repo_path} ${file}
+done
+update_repo ${tmp_repo_path}

-        echo "Syncing ${package}.asc to ${s3_bucket_repo}..."
-        aws s3 cp ${tmp_repo_path}/${package}.asc ${s3_bucket_repo}/${package}.asc --acl public-read
-      fi
-    fi
-  done
-  aws cloudfront create-invalidation --distribution-id ${AWS_CLOUDFRONT_DIST_ID} --paths ${cloudfront_path}/*.asc
-  sign_repo ${tmp_repo_path}
-fi
+# publish
+for file in "${files[@]}"; do
+  package=$(basename -- ${file})
+  echo "Publishing ${package} to ${s3_bucket_repo}..."
+  aws s3 cp ${tmp_repo_path}/${package} ${s3_bucket_repo}/${package} --acl public-read
+  aws s3 cp ${tmp_repo_path}/${package}.asc ${s3_bucket_repo}/${package}.asc --acl public-read

-# update the repo by adding new packages
-if ! [ ${#files[@]} -eq 0 ]; then
-  for file in "${files[@]}"; do
-    echo "Adding ${file}..."
-    add_rpm ${tmp_repo_path} ${file}
-  done
-  update_repo ${tmp_repo_path}
-  sign_repo ${tmp_repo_path}
-
-  # publish
-  for file in "${files[@]}"; do
-    package=$(basename -- ${file})
-    echo "Publishing ${package} to ${s3_bucket_repo}..."
-    aws s3 cp ${tmp_repo_path}/${package} ${s3_bucket_repo}/${package} --acl public-read
-    aws s3 cp ${tmp_repo_path}/${package}.asc ${s3_bucket_repo}/${package}.asc --acl public-read
-
-    aws cloudfront create-invalidation --distribution-id ${AWS_CLOUDFRONT_DIST_ID} --paths ${cloudfront_path}/${package}
-    aws cloudfront create-invalidation --distribution-id ${AWS_CLOUDFRONT_DIST_ID} --paths ${cloudfront_path}/${package}.asc
-  done
-fi
+  aws cloudfront create-invalidation --distribution-id ${AWS_CLOUDFRONT_DIST_ID} --paths ${cloudfront_path}/${package}
+  aws cloudfront create-invalidation --distribution-id ${AWS_CLOUDFRONT_DIST_ID} --paths ${cloudfront_path}/${package}.asc
+done

 # sync repodata
 aws s3 sync ${tmp_repo_path}/repodata ${s3_bucket_repo}/repodata --delete --acl public-read
-aws cloudfront create-invalidation --distribution-id ${AWS_CLOUDFRONT_DIST_ID} --paths ${cloudfront_path}/repodata/*
+aws cloudfront create-invalidation --distribution-id ${AWS_CLOUDFRONT_DIST_ID} --paths ${cloudfront_path}/repodata/*
--- a/scripts/systemd/falco-bpf.service
+++ b/scripts/systemd/falco-bpf.service
@@ -1,14 +1,14 @@
 [Unit]
-Description=Falco: Container Native Runtime Security with ebpf
+Description=Falco: Container Native Runtime Security
 Documentation=https://falco.org/docs/
-Before=falcoctl-artifact-follow.service
-Wants=falcoctl-artifact-follow.service
+After=falco_inject_kmod.service
+Requires=falco_inject_kmod.service

 [Service]
 Type=simple
 User=root
-Environment=FALCO_BPF_PROBE=
 ExecStart=/usr/bin/falco --pidfile=/var/run/falco.pid
+ExecStopPost=/sbin/rmmod falco
 UMask=0077
 TimeoutSec=30
 RestartSec=15s
@@ -18,6 +18,7 @@ NoNewPrivileges=yes
 ProtectHome=read-only
 ProtectSystem=full
 ProtectKernelTunables=true
+ReadWritePaths=/sys/module/falco
 RestrictRealtime=true
 RestrictAddressFamilies=~AF_PACKET
 StandardOutput=null
--- a/scripts/rpm/falco_inject_kmod.service
+++ b/scripts/rpm/falco_inject_kmod.service
@@ -0,0 +1,13 @@
+[Unit]
+Description=Falco: Container Native Runtime Security
+Documentation=https://falco.org/docs/
+Before=falco.service
+Wants=falco.service
+
+[Service]
+Type=oneshot
+User=root
+ExecStart=/sbin/modprobe falco
+
+[Install]
+WantedBy=multi-user.target
--- a/scripts/rpm/postinstall.in
+++ b/scripts/rpm/postinstall.in
@@ -14,78 +14,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
-chosen_driver=
-
-# Every time we call this script we want to stat from a clean state.
-echo "[POST-INSTALL] Disable all possible enabled 'falco' service:"
-systemctl --system stop 'falco-kmod.service' || true
-systemctl --system stop 'falco-bpf.service' || true
-systemctl --system stop 'falco-modern-bpf.service' || true
-systemctl --system stop 'falco-custom.service' || true
-systemctl --system stop 'falcoctl-artifact-follow.service' || true
-systemctl --system disable 'falco-kmod.service' || true
-systemctl --system disable 'falco-bpf.service' || true
-systemctl --system disable 'falco-modern-bpf.service' || true
-systemctl --system disable 'falco-custom.service' || true
-systemctl --system disable 'falcoctl-artifact-follow.service' || true
-
-# unmask falcoctl if it was masked
-systemctl --system unmask falcoctl-artifact-follow.service || true
-
-if [ $1 -ge 1 ]; then
-        if [ -x /usr/bin/dialog ] && [ "${FALCO_FRONTEND}" != "noninteractive" ]; then
-            # If dialog is installed, create a dialog to let users choose the correct driver for them
-            CHOICE=$(dialog --clear --title "Falco drivers" --menu "Choose your preferred driver:" 12 55 4 \
-                    1 "Manual configuration (no unit is started)" \
-                    2 "Kmod" \
-                    3 "eBPF" \
-                    4 "Modern eBPF" \
-                    2>&1 >/dev/tty)
-            case $CHOICE in
-                2)
-                    chosen_driver="kmod"
-                    ;;
-                3)
-                    chosen_driver="bpf"
-                    ;;
-                4)
-                    chosen_driver="modern-bpf"
-                    ;;
-            esac
-            if [ -n "$chosen_driver" ]; then
-              CHOICE=$(dialog --clear --title "Falcoctl" --menu "Do you want to follow automatic ruleset updates?" 10 40 2 \
-                      1 "Yes" \
-                      2 "No" \
-                      2>&1 >/dev/tty)
-              case $CHOICE in
-                  2)
-                      # we don't want falcoctl enabled, we mask it
-                      systemctl --system mask falcoctl-artifact-follow.service || true
-                  ;;
-              esac
-            fi
-            clear
-        fi
-fi
-
 set -e

-echo "[POST-INSTALL] Trigger deamon-reload:"
-systemctl --system daemon-reload || true
-
-# If needed, try to load/compile the driver through falco-driver-loader
-case "$chosen_driver" in
-    "kmod")
-      # Only compile for kmod, in this way we use dkms
-      echo "[POST-INSTALL] Call 'falco-driver-loader --compile module':"
-      falco-driver-loader --compile module
-      ;;
-    "bpf")
-      echo "[POST-INSTALL] Call 'falco-driver-loader bpf':"
-      falco-driver-loader bpf
-      ;;
-esac
+mod_version="@DRIVER_VERSION@"
+dkms add -m falco -v $mod_version --rpm_safe_upgrade
+if [ `uname -r | grep -c "BOOT"` -eq 0 ] && [ -e /lib/modules/`uname -r`/build/include ]; then
+	dkms build -m falco -v $mod_version
+	dkms install --force -m falco -v $mod_version
+elif [ `uname -r | grep -c "BOOT"` -gt 0 ]; then
+	echo -e ""
+	echo -e "Module build for the currently running kernel was skipped since you"
+	echo -e "are running a BOOT variant of the kernel."
+else
+	echo -e ""
+	echo -e "Module build for the currently running kernel was skipped since the"
+	echo -e "kernel source for this kernel does not seem to be installed."
+fi

 # validate rpm macros by `rpm -qp --scripts <rpm>`
 # RPM scriptlets: https://docs.fedoraproject.org/en-US/packaging-guidelines/Scriptlets/#_systemd
@@ -94,14 +38,27 @@ esac
 # systemd_post macro expands to
 # if postinst:
 #   `systemd-update-helper install-system-units <service>`
-%systemd_post "falco-$chosen_driver.service"
+%systemd_post 'falco.service'

-# post install/upgrade mirrored from .deb
-if [ $1 -ge 1 ]; then
-        if [ -n "$chosen_driver" ]; then
-            echo "[POST-INSTALL] Enable 'falco-$chosen_driver.service':"
-            systemctl --system enable "falco-$chosen_driver.service" || true
-            echo "[POST-INSTALL] Start 'falco-$chosen_driver.service':"
-            systemctl --system start "falco-$chosen_driver.service" || true
-        fi
+# post install mirrored from .deb
+if [ $1 -eq 1 ]; then
+        # This will only remove masks created on package removal.
+        /usr/bin/systemctl --system unmask 'falco.service' >/dev/null || true
+
+        # enable falco on installation
+        # note: DEB postinstall script checks for changed symlinks
+        /usr/bin/systemctl --system enable 'falco.service' >/dev/null || true
+
+        # start falco on installation
+        /usr/bin/systemctl --system start 'falco.service' >/dev/null || true
+fi
+
+# post upgrade mirrored from .deb
+if [ $1 -gt 1 ]; then
+    if [ -d /run/systemd/system ]; then
+        /usr/bin/systemctl --system daemon-reload >/dev/null || true
+
+        # restart falco on upgrade if service is already running
+        /usr/bin/systemctl --system condrestart 'falco.service' >/dev/null || true
+    fi
 fi
--- a/scripts/rpm/postuninstall.in
+++ b/scripts/rpm/postuninstall.in
@@ -17,14 +17,17 @@

 set -e

-if [ -d /run/systemd/system ] && [ $1 -eq 0 ]; then
-        echo "[POST-REMOVE] Disable all Falco services:"
-        systemctl --system disable 'falco-kmod.service'|| true
-        systemctl --system disable 'falco-bpf.service' || true
-        systemctl --system disable 'falco-modern-bpf.service' || true
-        systemctl --system disable 'falco-custom.service' || true
-        systemctl --system disable 'falcoctl-artifact-follow.service' || true
-
-        echo "[POST-REMOVE] Trigger deamon-reload:"
-        systemctl --system daemon-reload || true
+# post uninstall mirrored from .deb
+if [ -d /run/systemd/system ] && [ "$1" = 0 ]; then
+        /usr/bin/systemctl --system daemon-reload >/dev/null || true
+        /usr/bin/systemctl --system mask 'falco.service' >/dev/null || true
 fi
+
+# validate rpm macros by `rpm -qp --scripts <rpm>`
+# RPM scriptlets: https://docs.fedoraproject.org/en-US/packaging-guidelines/Scriptlets/#_systemd
+#                 https://docs.fedoraproject.org/en-US/packaging-guidelines/Scriptlets/#_syntax
+
+# systemd_postun_with_restart macro expands to
+# if package upgrade, not uninstall:
+#   `systemd-update-helper mark-restart-system-units <service>`
+%systemd_postun_with_restart 'falco.service'
--- a/scripts/rpm/preuninstall.in
+++ b/scripts/rpm/preuninstall.in
@@ -16,16 +16,14 @@
 #
 set -e

+# pre uninstall mirrored from .deb
 # Currently running falco service uses the driver, so stop it before driver cleanup
-echo "[PRE-REMOVE] Stop all Falco services:"
-systemctl --system stop 'falco-kmod.service' || true
-systemctl --system stop 'falco-bpf.service' || true
-systemctl --system stop 'falco-modern-bpf.service' || true
-systemctl --system stop 'falco-custom.service' || true
-systemctl --system stop 'falcoctl-artifact-follow.service' || true
+if [ -d /run/systemd/system ] && [ $1 -eq 0 ]; then
+        # stop falco service before uninstall
+        /usr/bin/systemctl --system stop 'falco.service' >/dev/null || true
+fi

-echo "[PRE-REMOVE] Call 'falco-driver-loader --clean:'"
-falco-driver-loader --clean
+/usr/bin/falco-driver-loader --clean

 # validate rpm macros by `rpm -qp --scripts <rpm>`
 # RPM scriptlets: https://docs.fedoraproject.org/en-US/packaging-guidelines/Scriptlets/#_systemd
@@ -34,8 +32,4 @@ falco-driver-loader --clean
 # systemd_preun macro expands to
 # if preuninstall:
 #  `systemd-update-helper remove-system-units <service>`
-%systemd_preun 'falco-kmod.service'
-%systemd_preun 'falco-bpf.service'
-%systemd_preun 'falco-modern-bpf.service'
-%systemd_preun 'falco-custom.service'
-%systemd_preun 'falcoctl-artifact-follow.service'
+%systemd_preun 'falco.service'
--- a/scripts/systemd/falco-kmod-inject.service
+++ b/scripts/systemd/falco-kmod-inject.service
@@ -1,11 +0,0 @@
-[Unit]
-Description=Falco: Container Native Runtime Security with kmod, inject.
-Documentation=https://falco.org/docs/
-PartOf=falco-kmod.service
-
-[Service]
-Type=oneshot
-RemainAfterExit=yes
-User=root
-ExecStart=/sbin/modprobe falco
-ExecStop=/sbin/rmmod falco
--- a/scripts/systemd/falco-kmod.service
+++ b/scripts/systemd/falco-kmod.service
@@ -1,29 +0,0 @@
-[Unit]
-Description=Falco: Container Native Runtime Security with kmod
-Documentation=https://falco.org/docs/
-After=falco-kmod-inject.service
-Requires=falco-kmod-inject.service
-Before=falcoctl-artifact-follow.service
-Wants=falcoctl-artifact-follow.service
-
-[Service]
-Type=simple
-User=root
-ExecStart=/usr/bin/falco --pidfile=/var/run/falco.pid
-UMask=0077
-TimeoutSec=30
-RestartSec=15s
-Restart=on-failure
-PrivateTmp=true
-NoNewPrivileges=yes
-ProtectHome=read-only
-ProtectSystem=full
-ProtectKernelTunables=true
-ReadWriteDirectories=/sys/module/falco
-RestrictRealtime=true
-RestrictAddressFamilies=~AF_PACKET
-StandardOutput=null
-
-[Install]
-WantedBy=multi-user.target
-Alias=falco.service
--- a/scripts/systemd/falco-modern-bpf.service
+++ b/scripts/systemd/falco-modern-bpf.service
@@ -1,25 +0,0 @@
-[Unit]
-Description=Falco: Container Native Runtime Security with modern ebpf
-Documentation=https://falco.org/docs/
-Before=falcoctl-artifact-follow.service
-Wants=falcoctl-artifact-follow.service
-
-[Service]
-Type=simple
-User=root
-ExecStart=/usr/bin/falco --pidfile=/var/run/falco.pid --modern-bpf
-UMask=0077
-TimeoutSec=30
-RestartSec=15s
-Restart=on-failure
-PrivateTmp=true
-NoNewPrivileges=yes
-ProtectHome=read-only
-ProtectSystem=full
-ProtectKernelTunables=true
-RestrictRealtime=true
-RestrictAddressFamilies=~AF_PACKET
-StandardOutput=null
-
-[Install]
-WantedBy=multi-user.target
--- a/scripts/systemd/falcoctl-artifact-follow.service
+++ b/scripts/systemd/falcoctl-artifact-follow.service
@@ -1,22 +0,0 @@
-[Unit]
-Description=Falcoctl Artifact Follow: automatic artifacts update service
-Documentation=https://falco.org/docs/
-PartOf=falco-bpf.service falco-kmod.service falco-modern-bpf.service falco-custom.service
-
-[Service]
-Type=simple
-User=root
-ExecStart=/usr/bin/falcoctl artifact follow --allowed-types=rulesfile
-UMask=0077
-TimeoutSec=30
-RestartSec=15s
-Restart=on-failure
-PrivateTmp=true
-NoNewPrivileges=yes
-ProtectSystem=true
-ReadWriteDirectories=/usr/share/falco
-ProtectKernelTunables=true
-RestrictRealtime=true
-
-[Install]
-WantedBy=multi-user.target
--- a/submodules/falcosecurity-rules
+++ b/submodules/falcosecurity-rules
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,6 +1,4 @@
 add_subdirectory(trace_files)

-if(NOT MUSL_OPTIMIZED_BUILD)
-    add_subdirectory(plugins)
-    add_subdirectory(confs/plugins)
-endif()
+add_subdirectory(plugins)
+add_subdirectory(confs/plugins)
--- a/test/falco_k8s_audit_tests.yaml
+++ b/test/falco_k8s_audit_tests.yaml
@@ -21,7 +21,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - ./rules/k8s_audit/engine_v4_k8s_audit_rules.yaml
      - ./rules/k8s_audit/engine_v4/allow_only_apache_container.yaml
    detect_counts:
@@ -33,7 +33,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - ./rules/k8s_audit/engine_v4_k8s_audit_rules.yaml
      - ./rules/k8s_audit/engine_v4/allow_nginx_container.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
@@ -44,7 +44,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - ./rules/k8s_audit/engine_v4_k8s_audit_rules.yaml
    detect_counts:
      - Create Privileged Pod: 1
@@ -55,7 +55,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/engine_v4_k8s_audit_rules.yaml
      - ./rules/k8s_audit/trust_nginx_container.yaml
@@ -66,7 +66,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - ./rules/k8s_audit/engine_v4_k8s_audit_rules.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_unprivileged.json
@@ -76,7 +76,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - ./rules/k8s_audit/engine_v4_k8s_audit_rules.yaml
    detect_counts:
      - Create HostNetwork Pod: 1
@@ -87,7 +87,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/engine_v4_k8s_audit_rules.yaml
      - ./rules/k8s_audit/trust_nginx_container.yaml
@@ -99,7 +99,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/allow_namespace_foo.yaml
    detect_counts:
@@ -111,7 +111,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/allow_namespace_foo.yaml
      - ./rules/k8s_audit/allow_user_some-user.yaml
@@ -124,7 +124,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/allow_only_apache_container.yaml
    detect_counts:
@@ -136,7 +136,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/allow_nginx_container.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
@@ -147,7 +147,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - Create Privileged Pod: 1
@@ -159,7 +159,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - Create Privileged Pod: 1
@@ -171,7 +171,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - Create Privileged Pod: 1
@@ -182,7 +182,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/trust_nginx_container.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
@@ -192,7 +192,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_unprivileged.json
@@ -201,7 +201,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/trust_nginx_container.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
@@ -212,7 +212,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - Create Sensitive Mount Pod: 1
@@ -224,7 +224,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - Create Sensitive Mount Pod: 1
@@ -235,7 +235,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/trust_nginx_container.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
@@ -245,7 +245,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_unsensitive_mount.json
@@ -254,7 +254,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/trust_nginx_container.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
@@ -265,7 +265,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - Create HostNetwork Pod: 1
@@ -276,7 +276,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/trust_nginx_container.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
@@ -286,7 +286,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_nohostnetwork.json
@@ -295,7 +295,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/trust_nginx_container.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
@@ -306,7 +306,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/disallow_kactivity.yaml
    detect_counts:
@@ -318,7 +318,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/disallow_kactivity.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
@@ -329,7 +329,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/disallow_kactivity.yaml
    detect_counts:
@@ -341,7 +341,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/disallow_kactivity.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
@@ -352,7 +352,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - Anonymous Request Allowed: 1
@@ -364,7 +364,7 @@ trace_files: !mux
    detect_level: NOTICE
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - Attach/Exec Pod: 1
@@ -376,7 +376,7 @@ trace_files: !mux
    detect_level: NOTICE
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - Attach/Exec Pod: 1
@@ -388,7 +388,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/allow_user_some-user.yaml
    detect_counts:
@@ -400,7 +400,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/allow_namespace_foo.yaml
      - ./rules/k8s_audit/disallow_kactivity.yaml
@@ -412,7 +412,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - Pod Created in Kube Namespace: 1
@@ -424,7 +424,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - Pod Created in Kube Namespace: 1
@@ -436,7 +436,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - Service Account Created in Kube Namespace: 1
@@ -448,7 +448,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - Service Account Created in Kube Namespace: 1
@@ -460,7 +460,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - System ClusterRole Modified/Deleted: 1
@@ -472,7 +472,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - System ClusterRole Modified/Deleted: 1
@@ -484,7 +484,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - Attach to cluster-admin Role: 1
@@ -496,7 +496,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - ClusterRole With Wildcard Created: 1
@@ -508,7 +508,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - ClusterRole With Wildcard Created: 1
@@ -520,7 +520,7 @@ trace_files: !mux
    detect_level: NOTICE
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - ClusterRole With Write Privileges Created: 1
@@ -532,7 +532,7 @@ trace_files: !mux
    detect_level: WARNING
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - ClusterRole With Pod Exec Created: 1
@@ -544,7 +544,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - K8s Deployment Created: 1
@@ -556,7 +556,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - K8s Deployment Deleted: 1
@@ -568,7 +568,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - K8s Service Created: 1
@@ -580,7 +580,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - K8s Service Deleted: 1
@@ -592,7 +592,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - K8s ConfigMap Created: 1
@@ -604,7 +604,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - K8s ConfigMap Deleted: 1
@@ -616,7 +616,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
      - ./rules/k8s_audit/allow_namespace_foo.yaml
      - ./rules/k8s_audit/allow_user_some-user.yaml
@@ -630,7 +630,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - K8s Namespace Deleted: 1
@@ -642,7 +642,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - K8s Serviceaccount Created: 1
@@ -654,7 +654,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - K8s Serviceaccount Deleted: 1
@@ -666,7 +666,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - K8s Role/Clusterrole Created: 1
@@ -678,7 +678,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - K8s Role/Clusterrole Deleted: 1
@@ -690,7 +690,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - K8s Role/Clusterrolebinding Created: 1
@@ -702,7 +702,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - K8s Role/Clusterrolebinding Deleted: 1
@@ -714,7 +714,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - K8s Secret Created: 1
@@ -727,7 +727,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_service_account_token_secret.json
@@ -737,7 +737,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_kube_system_secret.json
@@ -747,7 +747,7 @@ trace_files: !mux
    detect_level: INFO
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    detect_counts:
      - K8s Secret Deleted: 1
@@ -758,7 +758,7 @@ trace_files: !mux
    detect: False
    enable_source: k8s_audit
    rules_file:
-      - BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml
+      - ../rules/falco_rules.yaml
      - BUILD_DIR/k8saudit-rules-prefix/src/k8saudit-rules/k8s_audit_rules.yaml
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/fal_01_003.json
@@ -773,4 +773,4 @@ trace_files: !mux
    detect_counts:
      - json_pointer_example: 1
    conf_file: BUILD_DIR/test/confs/plugins/k8s_audit.yaml
-    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_unprivileged.json
+    addl_cmdline_opts: -o plugins[0].open_params=trace_files/k8s_audit/create_nginx_pod_unprivileged.json
--- a/test/falco_test.py
+++ b/test/falco_test.py
@@ -99,7 +99,7 @@ class FalcoTest(Test):
        self.addl_cmdline_opts = self.params.get('addl_cmdline_opts', '*', default='')
        self.enable_source = self.params.get('enable_source', '*', default='')
        self.rules_file = self.params.get(
-            'rules_file', '*', default='BUILD_DIR/falcosecurity-rules-falco-prefix/src/falcosecurity-rules-falco/falco_rules.yaml')
+            'rules_file', '*', default=os.path.join(self.basedir, '../rules/falco_rules.yaml'))

        if not isinstance(self.rules_file, list):
            self.rules_file = [self.rules_file]
--- a/test/falco_tests.yaml
+++ b/test/falco_tests.yaml
@@ -358,16 +358,6 @@ trace_files: !mux
    validate_rules_file:
      - rules/invalid_macro_without_condition.yaml
    trace_file: trace_files/cat_write.scap
-  
-  invalid_macro_loop:
-    exit_status: 1
-    validate_errors:
-      - item_type: macro
-        item_name: macro_a
-        code: LOAD_ERR_VALIDATE
-        message_contains: "reference loop in macro"
-    validate_rules_file:
-      - rules/invalid_macro_loop.yaml

  invalid_rule_without_output:
    exit_status: 1
@@ -413,16 +403,6 @@ trace_files: !mux
      - rules/list_append_failure.yaml
    trace_file: trace_files/cat_write.scap

-  invalid_list_loop:
-    exit_status: 1
-    validate_errors:
-      - item_type: rule
-        item_name: sample rule
-        code: LOAD_ERR_COMPILE_CONDITION
-        message: "unknown event type list_a"
-    validate_rules_file:
-      - rules/invalid_list_loop.yaml
-
  invalid_rule_append_dangling:
    exit_status: 1
    validate_errors:
@@ -624,7 +604,7 @@ trace_files: !mux

  disabled_and_enabled_rules_1:
    exit_status: 1
-    stderr_contains: "Error: You can not specify both disabled .-D/-T. and enabled .-t. rules"
+    stderr_contains: "Runtime error: You can not specify both disabled .-D/-T. and enabled .-t. rules. Exiting."
    disable_tags: [a]
    run_tags: [a]
    rules_file:
@@ -633,7 +613,7 @@ trace_files: !mux

  disabled_and_enabled_rules_2:
    exit_status: 1
-    stderr_contains: "Error: You can not specify both disabled .-D/-T. and enabled .-t. rules"
+    stderr_contains: "Runtime error: You can not specify both disabled .-D/-T. and enabled .-t. rules. Exiting."
    disabled_rules:
      - "open.*"
    run_tags: [a]
--- a/test/falco_tests_plugins.yaml
+++ b/test/falco_tests_plugins.yaml
@@ -56,7 +56,7 @@ trace_files: !mux

  incompatible_extract_sources:
    exit_status: 1
-    stderr_contains: "Plugin '.*' is loaded but unused as not compatible with any known event source"
+    stderr_contains: "Plugin '.*' has field extraction capability but is not compatible with any known event source"
    conf_file: BUILD_DIR/test/confs/plugins/incompatible_extract_sources.yaml
    rules_file:
      - rules/plugins/cloudtrail_create_instances.yaml
--- a/test/plugins/test_extract.cpp
+++ b/test/plugins/test_extract.cpp
@@ -17,7 +17,7 @@ limitations under the License.
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <engine/source_plugin/plugin_info.h>
+#include <plugin_info.h>

 static const char *pl_required_api_version = PLUGIN_API_VERSION_STR;
 static const char *pl_name_base            = "test_extract";
--- a/test/plugins/test_source.cpp
+++ b/test/plugins/test_source.cpp
@@ -18,7 +18,7 @@ limitations under the License.
 #include <stdio.h>
 #include <stdlib.h>

-#include <engine/source_plugin/plugin_info.h>
+#include <plugin_info.h>

 static const char *pl_required_api_version = PLUGIN_API_VERSION_STR;
 static uint32_t    pl_id                   = 999;
--- a/test/requirements.txt
+++ b/test/requirements.txt
@@ -1,6 +1,6 @@
 avocado-framework==69.0
 avocado-framework-plugin-varianter-yaml-to-mux==69.0
-certifi==2022.12.7
+certifi==2020.4.5.1
 chardet==3.0.4
 idna==2.9
 pathtools==0.1.2
--- a/test/rules/invalid_list_loop.yaml
+++ b/test/rules/invalid_list_loop.yaml
@@ -1,17 +0,0 @@
- list: list_a
-  items: [open]
-
- list: list_b
-  items: [list_a]
-
- list: list_a
-  items: [list_b]
-
- macro: macro_a
-  condition: evt.type in (list_a)
-
- rule: sample rule
-  priority: WARNING
-  output: test
-  desc: testdesc
-  condition: macro_a
--- a/test/rules/invalid_macro_loop.yaml
+++ b/test/rules/invalid_macro_loop.yaml
@@ -1,8 +0,0 @@
- macro: macro_a
-  condition: evt.type=open
-
- macro: macro_b
-  condition: macro_a
-
- macro: macro_a
-  condition: macro_b
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -0,0 +1,76 @@
+#
+# Copyright (C) 2019 The Falco Authors.
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+#
+set(
+  FALCO_TESTS_SOURCES
+  test_base.cpp
+  engine/test_rulesets.cpp
+  engine/test_falco_utils.cpp
+  engine/test_filter_macro_resolver.cpp
+  engine/test_filter_evttype_resolver.cpp
+  engine/test_filter_warning_resolver.cpp
+  engine/test_plugin_requirements.cpp
+  falco/test_configuration.cpp
+)
+
+set(FALCO_TESTED_LIBRARIES falco_engine ${YAMLCPP_LIB})
+
+SET(FALCO_TESTS_ARGUMENTS "" CACHE STRING "Test arguments to pass to the Falco test suite")
+
+option(FALCO_BUILD_TESTS "Determines whether to build tests." ON)
+
+if(FALCO_BUILD_TESTS)
+  enable_testing()
+  if(NOT TARGET catch)
+    include(DownloadCatch)
+  endif()
+
+  if(NOT TARGET fakeit)
+    include(DownloadFakeIt)
+  endif()
+
+  add_executable(falco_test ${FALCO_TESTS_SOURCES})
+
+  target_link_libraries(falco_test PUBLIC ${FALCO_TESTED_LIBRARIES})
+
+  if(MINIMAL_BUILD)
+    target_include_directories(
+      falco_test
+      PUBLIC "${CATCH2_INCLUDE}"
+            "${FAKEIT_INCLUDE}"
+            "${PROJECT_SOURCE_DIR}/userspace/engine"
+            "${PROJECT_BINARY_DIR}/userspace/falco"
+            "${YAMLCPP_INCLUDE_DIR}"
+            "${PROJECT_SOURCE_DIR}/userspace/falco")
+  else()
+    target_include_directories(
+      falco_test
+      PUBLIC "${CATCH2_INCLUDE}"
+            "${FAKEIT_INCLUDE}"
+            "${PROJECT_SOURCE_DIR}/userspace/engine"
+            "${PROJECT_BINARY_DIR}/userspace/falco"
+            "${YAMLCPP_INCLUDE_DIR}"
+            "${PROJECT_SOURCE_DIR}/userspace/falco")
+  endif()
+  add_dependencies(falco_test catch2)
+
+  include(CMakeParseArguments)
+  include(CTest)
+  include(Catch)
+  catch_discover_tests(falco_test)
+  separate_arguments(FALCO_TESTS_ARGUMENTS)
+  add_custom_target(tests COMMAND ${CMAKE_CTEST_COMMAND} ${FALCO_TESTS_ARGUMENTS} DEPENDS falco_test)
+endif()
--- a/tests/OWNERS
+++ b/tests/OWNERS
@@ -0,0 +1,2 @@
+labels:
+  - area/tests
--- a/tests/README.md
+++ b/tests/README.md
@@ -0,0 +1,57 @@
+# Falco unit tests
+
+This folder contains the unit-tests suite for Falco.
+The framework we use for unit-tests is [Catch2](https://github.com/catchorg/Catch2), while the one we use for mocking is [FakeIt](https://github.com/eranpeer/FakeIt).
+
+
+## How to write tests
+
+When you want to test a new file or test a non tested file, remember four steps:
+
+- The folder structure here is the same as the one in the `userspace` folder, so `userspace/engine` becomes `tests/engine`.
+- We call test files with this format `test_<original-file-name>.cpp`
+- Update the `CMakeLists.txt` file to include your file in `FALCO_TESTS_SOURCES` and change the `FALCO_TESTED_LIBRARIES` accordingly. You might also need to add dependencies, in that case, look at `target_link_libraries` and `target_include_directories`
+- If you are unsure on how to write tests, refer to our existing tests in this folder and to the [Catch2](https://github.com/catchorg/Catch2/tree/master/docs) documentation.
+
+## How to execute tests
+
+The suite can be configured with `cmake` and run with `make`.
+
+
+In the root folder of Falco, after creating the build directory:
+
+```bash
+cd falco
+mkdir build
+cd build
+```
+
+You can prepare the tests with:
+
+```
+cmake ..
+```
+
+Optionally, you can customize the test suite by passing custom arguments like the examples below:
+
+**filter all tests containing the word ctor**
+
+```bash
+cmake -DFALCO_TESTS_ARGUMENTS:STRING="-R ctor" ..
+```
+
+**verbose execution**
+
+```bash
+cmake -DFALCO_TESTS_ARGUMENTS:STRING="-V" ..
+```
+
+
+To see a list of all the custom arguments you may pass, execute `ctest --help` in your terminal.
+
+
+Once you are ready, you can run your configuration with:
+
+```bash
+make tests
+```
--- a/tests/engine/test_falco_utils.cpp
+++ b/tests/engine/test_falco_utils.cpp
@@ -0,0 +1,52 @@
+/*
+Copyright (C) 2020 The Falco Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+#include "falco_utils.h"
+#include <catch.hpp>
+
+TEST_CASE("is_unix_scheme matches", "[utils]")
+{
+	SECTION("rvalue")
+	{
+		bool res = falco::utils::network::is_unix_scheme("unix:///run/falco/falco.sock");
+		REQUIRE(res);
+	}
+
+	SECTION("std::string")
+	{
+		std::string url("unix:///run/falco/falco.sock");
+		bool res = falco::utils::network::is_unix_scheme(url);
+		REQUIRE(res);
+	}
+
+	SECTION("char[]")
+	{
+		char url[] = "unix:///run/falco/falco.sock";
+		bool res = falco::utils::network::is_unix_scheme(url);
+		REQUIRE(res);
+	}
+}
+
+TEST_CASE("is_unix_scheme does not match", "[utils]")
+{
+	bool res = falco::utils::network::is_unix_scheme("something:///run/falco/falco.sock");
+	REQUIRE_FALSE(res);
+}
+
+TEST_CASE("is_unix_scheme only matches scheme at the start of the string", "[utils]")
+{
+	bool res = falco::utils::network::is_unix_scheme("/var/run/unix:///falco.sock");
+	REQUIRE_FALSE(res);
+}
--- a/tests/engine/test_filter_evttype_resolver.cpp
+++ b/tests/engine/test_filter_evttype_resolver.cpp
@@ -0,0 +1,237 @@
+/*
+Copyright (C) 2021 The Falco Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+*/
+
+#include "filter_evttype_resolver.h"
+#include <catch.hpp>
+#include <sinsp.h>
+#include <filter/parser.h>
+
+using namespace std;
+using namespace libsinsp::filter;
+
+string to_string(set<uint16_t> s)
+{
+	string out = "[";
+	for(auto &val : s)
+	{
+        out += out.size() == 1 ? "" : ", ";
+		out += to_string(val);
+	}
+	out += "]";
+	return out;
+}
+
+void compare_evttypes(std::unique_ptr<ast::expr> f, set<uint16_t> &expected)
+{
+    set<uint16_t> actual;
+    filter_evttype_resolver().evttypes(f.get(), actual);
+    for(auto &etype : expected)
+    {
+        REQUIRE(actual.find(etype) != actual.end());
+    }
+    for(auto &etype : actual)
+    {
+        REQUIRE(expected.find(etype) != expected.end());
+    }
+}
+
+std::unique_ptr<ast::expr> compile(const string &fltstr)
+{
+    return libsinsp::filter::parser(fltstr).parse();
+}
+
+TEST_CASE("Should find event types from filter", "[rule_loader]")
+{
+    set<uint16_t> openat_only{
+        PPME_SYSCALL_OPENAT_E, PPME_SYSCALL_OPENAT_X,
+		PPME_SYSCALL_OPENAT_2_E, PPME_SYSCALL_OPENAT_2_X };
+
+	set<uint16_t> close_only{
+		PPME_SYSCALL_CLOSE_E, PPME_SYSCALL_CLOSE_X };
+
+	set<uint16_t> openat_close{
+        PPME_SYSCALL_OPENAT_E, PPME_SYSCALL_OPENAT_X,
+        PPME_SYSCALL_OPENAT_2_E, PPME_SYSCALL_OPENAT_2_X,
+        PPME_SYSCALL_CLOSE_E, PPME_SYSCALL_CLOSE_X };
+
+	set<uint16_t> not_openat;
+	set<uint16_t> not_openat_close;
+	set<uint16_t> not_close;
+	set<uint16_t> all_events;
+	set<uint16_t> no_events;
+
+    for(uint32_t i = 2; i < PPM_EVENT_MAX; i++)
+    {
+        // Skip events that are unused.
+        if(sinsp::is_unused_event(i))
+        {
+            continue;
+        }
+
+        all_events.insert(i);
+        if(openat_only.find(i) == openat_only.end())
+        {
+            not_openat.insert(i);
+        }
+        if(openat_close.find(i) == openat_close.end())
+        {
+            not_openat_close.insert(i);
+        }
+        if (close_only.find(i) == close_only.end())
+        {
+            not_close.insert(i);
+        }
+    }
+
+    SECTION("evt_type_eq")
+    {
+        auto f = compile("evt.type=openat");
+        compare_evttypes(std::move(f), openat_only);
+    }
+
+    SECTION("evt_type_in")
+    {
+        auto f = compile("evt.type in (openat, close)");
+        compare_evttypes(std::move(f), openat_close);
+    }
+
+    SECTION("evt_type_ne")
+    {
+        auto f = compile("evt.type!=openat");
+        compare_evttypes(std::move(f), not_openat);
+    }
+
+    SECTION("not_evt_type_eq")
+    {
+        auto f = compile("not evt.type=openat");
+        compare_evttypes(std::move(f), not_openat);
+    }
+
+    SECTION("not_evt_type_in")
+    {
+        auto f = compile("not evt.type in (openat, close)");
+        compare_evttypes(std::move(f), not_openat_close);
+    }
+
+    SECTION("not_evt_type_ne")
+    {
+        auto f = compile("not evt.type != openat");
+        compare_evttypes(std::move(f), openat_only);
+    }
+
+    SECTION("evt_type_or")
+    {
+        auto f = compile("evt.type=openat or evt.type=close");
+        compare_evttypes(std::move(f), openat_close);
+    }
+
+    SECTION("not_evt_type_or")
+    {
+        auto f = compile("evt.type!=openat or evt.type!=close");
+        compare_evttypes(std::move(f), all_events);
+    }
+
+    SECTION("evt_type_or_ne")
+    {
+        auto f = compile("evt.type=close or evt.type!=openat");
+        compare_evttypes(std::move(f), not_openat);
+    }
+
+    SECTION("evt_type_and")
+    {
+        auto f = compile("evt.type=close and evt.type=openat");
+        compare_evttypes(std::move(f), no_events);
+    }
+
+    SECTION("evt_type_and_non_evt_type")
+    {
+        auto f = compile("evt.type=openat and proc.name=nginx");
+        compare_evttypes(std::move(f), openat_only);
+    }
+
+    SECTION("evt_type_and_non_evt_type_not")
+    {
+        auto f = compile("evt.type=openat and not proc.name=nginx");
+        compare_evttypes(std::move(f), openat_only);
+    }
+
+    SECTION("evt_type_and_nested")
+    {
+        auto f = compile("evt.type=openat and (proc.name=nginx)");
+        compare_evttypes(std::move(f), openat_only);
+    }
+
+    SECTION("evt_type_and_nested_multi")
+    {
+        auto f = compile("evt.type=openat and (evt.type=close and proc.name=nginx)");
+        compare_evttypes(std::move(f), no_events);
+    }
+
+    SECTION("non_evt_type")
+    {
+        auto f = compile("proc.name=nginx");
+        compare_evttypes(std::move(f), all_events);
+    }
+
+    SECTION("non_evt_type_or")
+    {
+        auto f = compile("evt.type=openat or proc.name=nginx");
+        compare_evttypes(std::move(f), all_events);
+    }
+
+    SECTION("non_evt_type_or_nested_first")
+    {
+        auto f = compile("(evt.type=openat) or proc.name=nginx");
+        compare_evttypes(std::move(f), all_events);
+    }
+
+    SECTION("non_evt_type_or_nested_second")
+    {
+        auto f = compile("evt.type=openat or (proc.name=nginx)");
+        compare_evttypes(std::move(f), all_events);
+    }
+
+    SECTION("non_evt_type_or_nested_multi")
+    {
+        auto f = compile("evt.type=openat or (evt.type=close and proc.name=nginx)");
+        compare_evttypes(std::move(f), openat_close);
+    }
+
+    SECTION("non_evt_type_or_nested_multi_not")
+    {
+        auto f = compile("evt.type=openat or not (evt.type=close and proc.name=nginx)");
+        compare_evttypes(std::move(f), not_close);
+    }
+
+    SECTION("non_evt_type_and_nested_multi_not")
+    {
+        auto f = compile("evt.type=openat and not (evt.type=close and proc.name=nginx)");
+        compare_evttypes(std::move(f), openat_only);
+    }
+
+    SECTION("ne_and_and")
+    {
+        auto f = compile("evt.type!=openat and evt.type!=close");
+        compare_evttypes(std::move(f), not_openat_close);
+    }
+
+    SECTION("not_not")
+    {
+        auto f = compile("not (not evt.type=openat)");
+        compare_evttypes(std::move(f), openat_only);
+    }
+}
--- a/tests/engine/test_filter_macro_resolver.cpp
+++ b/tests/engine/test_filter_macro_resolver.cpp
@@ -0,0 +1,305 @@
+/*
+Copyright (C) 2020 The Falco Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include "filter_macro_resolver.h"
+#include <catch.hpp>
+
+using namespace std;
+using namespace libsinsp::filter::ast;
+
+static pos_info create_pos(uint32_t idx, uint32_t line, uint32_t col)
+{
+	pos_info ret;
+	ret.idx = idx;
+	ret.line = line;
+	ret.col = col;
+
+	return ret;
+}
+
+static bool operator==(const pos_info& p1, const pos_info& p2)
+{
+	return (p1.idx == p2.idx) &&
+		(p1.line == p2.line) &&
+		(p1.col == p2.col);
+}
+
+TEST_CASE("Should resolve macros on a filter AST", "[rule_loader]")
+{
+	string macro_name = "test_macro";
+	pos_info macro_pos = create_pos(12, 85, 27);
+
+	SECTION("in the general case")
+	{
+		std::shared_ptr<expr> macro = std::move(
+			unary_check_expr::create("test.field", "", "exists"));
+
+		std::vector<std::unique_ptr<expr>> filter_and;
+		filter_and.push_back(unary_check_expr::create("evt.name", "", "exists"));
+		filter_and.push_back(not_expr::create(value_expr::create(macro_name, macro_pos)));
+		std::shared_ptr<expr> filter = std::move(and_expr::create(filter_and));
+
+		std::vector<std::unique_ptr<expr>> expected_and;
+		expected_and.push_back(unary_check_expr::create("evt.name", "", "exists"));
+		expected_and.push_back(not_expr::create(clone(macro.get())));
+		std::shared_ptr<expr> expected = std::move(and_expr::create(expected_and));
+
+		filter_macro_resolver resolver;
+		resolver.set_macro(macro_name, macro);
+
+		// first run
+		REQUIRE(resolver.run(filter) == true);
+		REQUIRE(resolver.get_resolved_macros().size() == 1);
+		REQUIRE(resolver.get_resolved_macros().begin()->first == macro_name);
+		REQUIRE(resolver.get_resolved_macros().begin()->second == macro_pos);
+		REQUIRE(resolver.get_unknown_macros().empty());
+		REQUIRE(filter->is_equal(expected.get()));
+
+		// second run
+		REQUIRE(resolver.run(filter) == false);
+		REQUIRE(resolver.get_resolved_macros().empty());
+		REQUIRE(resolver.get_unknown_macros().empty());
+		REQUIRE(filter->is_equal(expected.get()));
+	}
+
+	SECTION("with a single node")
+	{
+		std::shared_ptr<expr> macro = std::move(
+			unary_check_expr::create("test.field", "", "exists"));
+
+		std::shared_ptr<expr> filter = std::move(value_expr::create(macro_name, macro_pos));
+
+		filter_macro_resolver resolver;
+		resolver.set_macro(macro_name, macro);
+
+		// first run
+		expr* old_filter_ptr = filter.get();
+		REQUIRE(resolver.run(filter) == true);
+		REQUIRE(filter.get() != old_filter_ptr);
+		REQUIRE(resolver.get_resolved_macros().size() == 1);
+		REQUIRE(resolver.get_resolved_macros().begin()->first == macro_name);
+		REQUIRE(resolver.get_resolved_macros().begin()->second == macro_pos);
+		REQUIRE(resolver.get_unknown_macros().empty());
+		REQUIRE(filter->is_equal(macro.get()));
+
+		// second run
+		old_filter_ptr = filter.get();
+		REQUIRE(resolver.run(filter) == false);
+		REQUIRE(filter.get() == old_filter_ptr);
+		REQUIRE(resolver.get_resolved_macros().empty());
+		REQUIRE(resolver.get_unknown_macros().empty());
+		REQUIRE(filter->is_equal(macro.get()));
+	}
+
+	SECTION("with multiple macros")
+	{
+		string a_macro_name = macro_name + "_1";
+		string b_macro_name = macro_name + "_2";
+
+		pos_info a_macro_pos = create_pos(11, 75, 43);
+		pos_info b_macro_pos = create_pos(91, 21, 9);
+
+		std::shared_ptr<expr> a_macro = std::move(
+			unary_check_expr::create("one.field", "", "exists"));
+		std::shared_ptr<expr> b_macro = std::move(
+			unary_check_expr::create("another.field", "", "exists"));
+
+		std::vector<std::unique_ptr<expr>> filter_or;
+		filter_or.push_back(value_expr::create(a_macro_name, a_macro_pos));
+		filter_or.push_back(value_expr::create(b_macro_name, b_macro_pos));
+		std::shared_ptr<expr> filter = std::move(or_expr::create(filter_or));
+
+		std::vector<std::unique_ptr<expr>> expected_or;
+		expected_or.push_back(clone(a_macro.get()));
+		expected_or.push_back(clone(b_macro.get()));
+		std::shared_ptr<expr>  expected_filter = std::move(or_expr::create(expected_or));
+
+		filter_macro_resolver resolver;
+		resolver.set_macro(a_macro_name, a_macro);
+		resolver.set_macro(b_macro_name, b_macro);
+
+		// first run
+		REQUIRE(resolver.run(filter) == true);
+		REQUIRE(resolver.get_resolved_macros().size() == 2);
+		auto a_resolved_itr = resolver.get_resolved_macros().find(a_macro_name);
+		REQUIRE(a_resolved_itr != resolver.get_resolved_macros().end());
+		REQUIRE(a_resolved_itr->first == a_macro_name);
+		REQUIRE(a_resolved_itr->second == a_macro_pos);
+
+		auto b_resolved_itr = resolver.get_resolved_macros().find(b_macro_name);
+		REQUIRE(b_resolved_itr != resolver.get_resolved_macros().end());
+		REQUIRE(resolver.get_unknown_macros().empty());
+		REQUIRE(b_resolved_itr->first == b_macro_name);
+		REQUIRE(b_resolved_itr->second == b_macro_pos);
+		REQUIRE(filter->is_equal(expected_filter.get()));
+
+		// second run
+		REQUIRE(resolver.run(filter) == false);
+		REQUIRE(resolver.get_resolved_macros().empty());
+		REQUIRE(resolver.get_unknown_macros().empty());
+		REQUIRE(filter->is_equal(expected_filter.get()));
+	}
+
+	SECTION("with nested macros")
+	{
+		string a_macro_name = macro_name + "_1";
+		string b_macro_name = macro_name + "_2";
+
+		pos_info a_macro_pos = create_pos(47, 1, 76);
+		pos_info b_macro_pos = create_pos(111, 65, 2);
+
+		std::vector<std::unique_ptr<expr>> a_macro_and;
+		a_macro_and.push_back(unary_check_expr::create("one.field", "", "exists"));
+		a_macro_and.push_back(value_expr::create(b_macro_name, b_macro_pos));
+		std::shared_ptr<expr> a_macro = std::move(and_expr::create(a_macro_and));
+
+		std::shared_ptr<expr> b_macro = std::move(
+			unary_check_expr::create("another.field", "", "exists"));
+
+		std::shared_ptr<expr> filter = std::move(value_expr::create(a_macro_name, a_macro_pos));
+
+		std::vector<std::unique_ptr<expr>> expected_and;
+		expected_and.push_back(unary_check_expr::create("one.field", "", "exists"));
+		expected_and.push_back(unary_check_expr::create("another.field", "", "exists"));
+		std::shared_ptr<expr> expected_filter = std::move(and_expr::create(expected_and));
+
+		filter_macro_resolver resolver;
+		resolver.set_macro(a_macro_name, a_macro);
+		resolver.set_macro(b_macro_name, b_macro);
+
+		// first run
+		REQUIRE(resolver.run(filter) == true);
+		REQUIRE(resolver.get_resolved_macros().size() == 2);
+		auto a_resolved_itr = resolver.get_resolved_macros().find(a_macro_name);
+		REQUIRE(a_resolved_itr != resolver.get_resolved_macros().end());
+		REQUIRE(a_resolved_itr->first == a_macro_name);
+		REQUIRE(a_resolved_itr->second == a_macro_pos);
+
+		auto b_resolved_itr = resolver.get_resolved_macros().find(b_macro_name);
+		REQUIRE(b_resolved_itr != resolver.get_resolved_macros().end());
+		REQUIRE(resolver.get_unknown_macros().empty());
+		REQUIRE(b_resolved_itr->first == b_macro_name);
+		REQUIRE(b_resolved_itr->second == b_macro_pos);
+
+		REQUIRE(resolver.get_unknown_macros().empty());
+		REQUIRE(filter->is_equal(expected_filter.get()));
+
+		// second run
+		REQUIRE(resolver.run(filter) == false);
+		REQUIRE(resolver.get_resolved_macros().empty());
+		REQUIRE(resolver.get_unknown_macros().empty());
+		REQUIRE(filter->is_equal(expected_filter.get()));
+	}
+}
+
+TEST_CASE("Should find unknown macros", "[rule_loader]")
+{
+	string macro_name = "test_macro";
+	pos_info macro_pos = create_pos(9, 4, 2);
+
+	SECTION("in the general case")
+	{
+		std::vector<std::unique_ptr<expr>> filter_and;
+		filter_and.push_back(unary_check_expr::create("evt.name", "", "exists"));
+		filter_and.push_back(not_expr::create(value_expr::create(macro_name, macro_pos)));
+		std::shared_ptr<expr> filter = std::move(and_expr::create(filter_and));
+
+		filter_macro_resolver resolver;
+		REQUIRE(resolver.run(filter) == false);
+		REQUIRE(resolver.get_unknown_macros().size() == 1);
+		REQUIRE(resolver.get_unknown_macros().begin()->first == macro_name);
+		REQUIRE(resolver.get_unknown_macros().begin()->second == macro_pos);
+		REQUIRE(resolver.get_resolved_macros().empty());
+	}
+
+	SECTION("with nested macros")
+	{
+		string a_macro_name = macro_name + "_1";
+		string b_macro_name = macro_name + "_2";
+
+		pos_info a_macro_pos = create_pos(32, 84, 9);
+		pos_info b_macro_pos = create_pos(1, 0, 5);
+
+		std::vector<std::unique_ptr<expr>> a_macro_and;
+		a_macro_and.push_back(unary_check_expr::create("one.field", "", "exists"));
+		a_macro_and.push_back(value_expr::create(b_macro_name, b_macro_pos));
+		std::shared_ptr<expr> a_macro = std::move(and_expr::create(a_macro_and));
+
+		std::shared_ptr<expr> filter = std::move(value_expr::create(a_macro_name, a_macro_pos));
+		auto expected_filter = clone(a_macro.get());
+
+		filter_macro_resolver resolver;
+		resolver.set_macro(a_macro_name, a_macro);
+
+		// first run
+		REQUIRE(resolver.run(filter) == true);
+		REQUIRE(resolver.get_resolved_macros().size() == 1);
+		REQUIRE(resolver.get_resolved_macros().begin()->first == a_macro_name);
+		REQUIRE(resolver.get_resolved_macros().begin()->second == a_macro_pos);
+		REQUIRE(resolver.get_unknown_macros().size() == 1);
+		REQUIRE(resolver.get_unknown_macros().begin()->first == b_macro_name);
+		REQUIRE(resolver.get_unknown_macros().begin()->second == b_macro_pos);
+		REQUIRE(filter->is_equal(expected_filter.get()));
+	}
+}
+
+TEST_CASE("Should undefine macro", "[rule_loader]")
+{
+	string macro_name = "test_macro";
+	pos_info macro_pos_1 = create_pos(12, 9, 3);
+	pos_info macro_pos_2 = create_pos(9, 6, 3);
+
+	std::shared_ptr<expr> macro = std::move(unary_check_expr::create("test.field", "", "exists"));
+	std::shared_ptr<expr> a_filter = std::move(value_expr::create(macro_name, macro_pos_1));
+	std::shared_ptr<expr> b_filter = std::move(value_expr::create(macro_name, macro_pos_2));
+	filter_macro_resolver resolver;
+
+	resolver.set_macro(macro_name, macro);
+	REQUIRE(resolver.run(a_filter) == true);
+	REQUIRE(resolver.get_resolved_macros().size() == 1);
+	REQUIRE(resolver.get_resolved_macros().begin()->first == macro_name);
+	REQUIRE(resolver.get_resolved_macros().begin()->second == macro_pos_1);
+	REQUIRE(resolver.get_unknown_macros().empty());
+	REQUIRE(a_filter->is_equal(macro.get()));
+
+	resolver.set_macro(macro_name, NULL);
+	REQUIRE(resolver.run(b_filter) == false);
+	REQUIRE(resolver.get_resolved_macros().empty());
+	REQUIRE(resolver.get_unknown_macros().size() == 1);
+	REQUIRE(resolver.get_unknown_macros().begin()->first == macro_name);
+	REQUIRE(resolver.get_unknown_macros().begin()->second == macro_pos_2);
+}
+
+// checks that the macro AST is cloned and not shared across resolved filters
+TEST_CASE("Should clone macro AST", "[rule_loader]")
+{
+	string macro_name = "test_macro";
+	pos_info macro_pos = create_pos(5, 2, 8888);
+	std::shared_ptr<unary_check_expr> macro = std::move(unary_check_expr::create("test.field", "", "exists"));
+	std::shared_ptr<expr> filter = std::move(value_expr::create(macro_name, macro_pos));
+	filter_macro_resolver resolver;
+
+	resolver.set_macro(macro_name, macro);
+	REQUIRE(resolver.run(filter) == true);
+	REQUIRE(resolver.get_resolved_macros().size() == 1);
+	REQUIRE(resolver.get_resolved_macros().begin()->first == macro_name);
+	REQUIRE(resolver.get_resolved_macros().begin()->second == macro_pos);
+	REQUIRE(resolver.get_unknown_macros().empty());
+	REQUIRE(filter->is_equal(macro.get()));
+
+	macro->field = "another.field";
+	REQUIRE(!filter->is_equal(macro.get()));
+}
--- a/tests/engine/test_filter_warning_resolver.cpp
+++ b/tests/engine/test_filter_warning_resolver.cpp
@@ -0,0 +1,45 @@
+/*
+Copyright (C) 2020 The Falco Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include "filter_warning_resolver.h"
+#include <catch.hpp>
+
+static bool warns(const std::string& condition)
+{
+	std::set<falco::load_result::warning_code> w;
+	auto ast = libsinsp::filter::parser(condition).parse();
+	filter_warning_resolver().run(ast.get(), w);
+	return !w.empty();
+}
+
+TEST_CASE("Should spot warnings in filtering conditions", "[rule_loader]")
+{
+	SECTION("for unsafe usage of <NA> in k8s audit fields")
+	{
+		REQUIRE(false == warns("ka.field exists"));
+		REQUIRE(false == warns("some.field = <NA>"));
+		REQUIRE(true == warns("jevt.field = <NA>"));
+		REQUIRE(true == warns("ka.field = <NA>"));
+		REQUIRE(true == warns("ka.field == <NA>"));
+		REQUIRE(true == warns("ka.field != <NA>"));
+		REQUIRE(true == warns("ka.field in (<NA>)"));
+		REQUIRE(true == warns("ka.field in (otherval, <NA>)"));
+		REQUIRE(true == warns("ka.field intersects (<NA>)"));
+		REQUIRE(true == warns("ka.field intersects (otherval, <NA>)"));
+		REQUIRE(true == warns("ka.field pmatch (<NA>)"));
+		REQUIRE(true == warns("ka.field pmatch (otherval, <NA>)"));
+	}
+}
--- a/tests/engine/test_plugin_requirements.cpp
+++ b/tests/engine/test_plugin_requirements.cpp
@@ -0,0 +1,269 @@
+/*
+Copyright (C) 2022 The Falco Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include <memory>
+#include <catch.hpp>
+#include "falco_engine.h"
+
+static void check_requirements(
+        bool expect_success,
+        const std::vector<falco_engine::plugin_version_requirement>& plugins,
+        const std::string& ruleset_content)
+{
+    std::string err;
+    std::unique_ptr<falco_engine> e(new falco_engine());
+    falco::load_result::rules_contents_t c = {{"test", ruleset_content}};
+
+    auto res = e->load_rules(c.begin()->second, c.begin()->first);
+    if (!res->successful())
+    {
+        if (expect_success)
+        {
+            FAIL(res->as_string(false, c));
+        }
+        return;
+    }
+
+    if (!e->check_plugin_requirements(plugins, err))
+    {
+        if (expect_success)
+        {
+            FAIL(err);
+        }
+    }
+    else if (!expect_success)
+    {
+        FAIL("unexpected successful plugin requirements check");
+    }
+}
+
+TEST_CASE("check_plugin_requirements must accept", "[rule_loader]")
+{
+    SECTION("no requirement")
+    {
+        check_requirements(true, {{"k8saudit", "0.1.0"}}, "");
+    }
+
+    SECTION("single plugin")
+    {
+        check_requirements(true, {{"k8saudit", "0.1.0"}}, R"(
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.1.0
+        )");
+    }
+
+    SECTION("single plugin newer version")
+    {
+        check_requirements(true, {{"k8saudit", "0.2.0"}}, R"(
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.1.0
+        )");
+    }
+
+    SECTION("multiple plugins")
+    {
+        check_requirements(true, {{"k8saudit", "0.1.0"}, {"json", "0.3.0"}}, R"(
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.1.0
+  - name: json
+    version: 0.3.0
+        )");
+    }
+
+    SECTION("single plugin multiple versions")
+    {
+        check_requirements(true, {{"k8saudit", "0.2.0"}}, R"(
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.1.0
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.2.0
+        )");
+    }
+
+    SECTION("single plugin with alternatives")
+    {
+        check_requirements(true, {{"k8saudit-other", "0.5.0"}}, R"(
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.1.0
+    alternatives:
+      - name: k8saudit-other
+        version: 0.4.0
+        )");
+    }
+
+    SECTION("multiple plugins with alternatives")
+    {
+        check_requirements(true, {{"k8saudit-other", "0.5.0"}, {"json2", "0.5.0"}}, R"(
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.1.0
+    alternatives:
+      - name: k8saudit-other
+        version: 0.4.0
+  - name: json
+    version: 0.3.0
+    alternatives:
+      - name: json2
+        version: 0.1.0
+        )");
+    }
+
+    SECTION("multiple plugins with alternatives with multiple versions")
+    {
+        check_requirements(true, {{"k8saudit-other", "0.7.0"}, {"json2", "0.5.0"}}, R"(
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.1.0
+    alternatives:
+      - name: k8saudit-other
+        version: 0.4.0
+  - name: json
+    version: 0.3.0
+    alternatives:
+      - name: json2
+        version: 0.1.0
+- required_plugin_versions:
+  - name: k8saudit
+    version: 1.0.0
+    alternatives:
+      - name: k8saudit-other
+        version: 0.7.0
+        )");
+    }
+}
+
+TEST_CASE("check_plugin_requirements must reject", "[rule_loader]")
+{
+    SECTION("no plugin loaded")
+    {
+        check_requirements(false, {}, R"(
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.1.0
+        )");
+    }
+    
+    SECTION("single plugin wrong name")
+    {
+        check_requirements(false, {{"k8saudit", "0.1.0"}}, R"(
+- required_plugin_versions:
+  - name: k8saudit2
+    version: 0.1.0
+        )");
+    }
+
+    SECTION("single plugin wrong version")
+    {
+        check_requirements(false, {{"k8saudit", "0.1.0"}}, R"(
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.2.0
+        )");
+    }
+
+    SECTION("multiple plugins")
+    {
+        check_requirements(false, {{"k8saudit", "0.1.0"}}, R"(
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.1.0
+  - name: json
+    version: 0.3.0
+        )");
+    }
+
+    SECTION("single plugin multiple versions")
+    {
+        check_requirements(false, {{"k8saudit", "0.1.0"}}, R"(
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.1.0
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.2.0
+        )");
+    }
+
+    SECTION("single plugin with alternatives")
+    {
+        check_requirements(false, {{"k8saudit2", "0.5.0"}}, R"(
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.1.0
+    alternatives:
+      - name: k8saudit-other
+        version: 0.4.0
+        )");
+    }
+
+    SECTION("single plugin with overlapping alternatives")
+    {
+        check_requirements(false, {{"k8saudit", "0.5.0"}}, R"(
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.1.0
+    alternatives:
+      - name: k8saudit
+        version: 0.4.0
+        )");
+    }
+
+    SECTION("multiple plugins with alternatives")
+    {
+        check_requirements(false, {{"k8saudit-other", "0.5.0"}, {"json3", "0.5.0"}}, R"(
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.1.0
+    alternatives:
+      - name: k8saudit-other
+        version: 0.4.0
+  - name: json
+    version: 0.3.0
+    alternatives:
+      - name: json2
+        version: 0.1.0
+        )");
+    }
+
+    SECTION("multiple plugins with alternatives with multiple versions")
+    {
+        check_requirements(false, {{"k8saudit", "0.7.0"}, {"json2", "0.5.0"}}, R"(
+- required_plugin_versions:
+  - name: k8saudit
+    version: 0.4.0
+    alternatives:
+      - name: k8saudit-other
+        version: 0.4.0
+  - name: json
+    version: 0.3.0
+    alternatives:
+      - name: json2
+        version: 0.1.0
+- required_plugin_versions:
+  - name: k8saudit
+    version: 1.0.0
+    alternatives:
+      - name: k8saudit-other
+        version: 0.7.0
+        )");
+    }
+}
--- a/tests/engine/test_rulesets.cpp
+++ b/tests/engine/test_rulesets.cpp
@@ -0,0 +1,242 @@
+/*
+Copyright (C) 2020 The Falco Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include "falco_common.h"
+#include "evttype_index_ruleset.h"
+#include <filter.h>
+#include <catch.hpp>
+
+static bool exact_match = true;
+static bool substring_match = false;
+static uint16_t default_ruleset = 0;
+static uint16_t non_default_ruleset = 3;
+static uint16_t other_non_default_ruleset = 2;
+static std::set<std::string> tags = {"some_tag", "some_other_tag"};
+static std::set<uint16_t> evttypes = { ppm_event_type::PPME_GENERIC_E };
+
+static std::shared_ptr<gen_event_filter_factory> create_factory()
+{
+	std::shared_ptr<gen_event_filter_factory> ret(new sinsp_filter_factory(NULL));
+
+	return ret;
+}
+
+static std::shared_ptr<libsinsp::filter::ast::expr> create_ast(
+	std::shared_ptr<gen_event_filter_factory> f)
+{
+	libsinsp::filter::parser parser("evt.type=open");
+	std::shared_ptr<libsinsp::filter::ast::expr> ret(parser.parse());
+
+	return ret;
+}
+
+static std::shared_ptr<gen_event_filter> create_filter(
+	std::shared_ptr<gen_event_filter_factory> f,
+	std::shared_ptr<libsinsp::filter::ast::expr> ast)
+{
+	sinsp_filter_compiler compiler(f, ast.get());
+	std::shared_ptr<gen_event_filter> filter(compiler.compile());
+
+	return filter;
+}
+
+static std::shared_ptr<filter_ruleset> create_ruleset(
+	std::shared_ptr<gen_event_filter_factory> f)
+{
+	std::shared_ptr<filter_ruleset> ret(new evttype_index_ruleset(f));
+	return ret;
+}
+
+TEST_CASE("Should enable/disable on ruleset", "[rulesets]")
+{
+	auto f = create_factory();
+	auto r = create_ruleset(f);
+	auto ast = create_ast(f);
+	auto filter = create_filter(f, ast);
+	falco_rule rule;
+	rule.name = "one_rule";
+	rule.source = falco_common::syscall_source;
+	rule.tags = tags;
+
+	r->add(rule, filter, ast);
+
+	SECTION("Should enable/disable for exact match w/ default ruleset")
+	{
+		r->enable("one_rule", exact_match, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 1);
+
+		r->disable("one_rule", exact_match, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 0);
+	}
+
+	SECTION("Should enable/disable for exact match w/ specific ruleset")
+	{
+		r->enable("one_rule", exact_match, non_default_ruleset);
+		REQUIRE(r->enabled_count(non_default_ruleset) == 1);
+		REQUIRE(r->enabled_count(default_ruleset) == 0);
+		REQUIRE(r->enabled_count(other_non_default_ruleset) == 0);
+
+		r->disable("one_rule", exact_match, non_default_ruleset);
+		REQUIRE(r->enabled_count(non_default_ruleset) == 0);
+		REQUIRE(r->enabled_count(default_ruleset) == 0);
+		REQUIRE(r->enabled_count(other_non_default_ruleset) == 0);
+	}
+
+	SECTION("Should not enable for exact match different rule name")
+	{
+		r->enable("some_other_rule", exact_match, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 0);
+	}
+
+	SECTION("Should enable/disable for exact match w/ substring and default ruleset")
+	{
+		r->enable("one_rule", substring_match, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 1);
+
+		r->disable("one_rule", substring_match, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 0);
+	}
+
+	SECTION("Should not enable for substring w/ exact_match")
+	{
+		r->enable("one_", exact_match, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 0);
+	}
+
+	SECTION("Should enable/disable for prefix match w/ default ruleset")
+	{
+		r->enable("one_", substring_match, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 1);
+
+		r->disable("one_", substring_match, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 0);
+	}
+
+	SECTION("Should enable/disable for suffix match w/ default ruleset")
+	{
+		r->enable("_rule", substring_match, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 1);
+
+		r->disable("_rule", substring_match, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 0);
+	}
+
+	SECTION("Should enable/disable for substring match w/ default ruleset")
+	{
+		r->enable("ne_ru", substring_match, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 1);
+
+		r->disable("ne_ru", substring_match, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 0);
+	}
+
+	SECTION("Should enable/disable for substring match w/ specific ruleset")
+	{
+		r->enable("ne_ru", substring_match, non_default_ruleset);
+		REQUIRE(r->enabled_count(non_default_ruleset) == 1);
+		REQUIRE(r->enabled_count(default_ruleset) == 0);
+		REQUIRE(r->enabled_count(other_non_default_ruleset) == 0);
+
+		r->disable("ne_ru", substring_match, non_default_ruleset);
+		REQUIRE(r->enabled_count(non_default_ruleset) == 0);
+		REQUIRE(r->enabled_count(default_ruleset) == 0);
+		REQUIRE(r->enabled_count(other_non_default_ruleset) == 0);
+	}
+
+	SECTION("Should enable/disable for tags w/ default ruleset")
+	{
+		std::set<std::string> want_tags = {"some_tag"};
+
+		r->enable_tags(want_tags, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 1);
+
+		r->disable_tags(want_tags, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 0);
+	}
+
+	SECTION("Should enable/disable for tags w/ specific ruleset")
+	{
+		std::set<std::string> want_tags = {"some_tag"};
+
+		r->enable_tags(want_tags, non_default_ruleset);
+		REQUIRE(r->enabled_count(non_default_ruleset) == 1);
+		REQUIRE(r->enabled_count(default_ruleset) == 0);
+		REQUIRE(r->enabled_count(other_non_default_ruleset) == 0);
+
+		r->disable_tags(want_tags, non_default_ruleset);
+		REQUIRE(r->enabled_count(non_default_ruleset) == 0);
+		REQUIRE(r->enabled_count(default_ruleset) == 0);
+		REQUIRE(r->enabled_count(other_non_default_ruleset) == 0);
+	}
+
+	SECTION("Should not enable for different tags")
+	{
+		std::set<std::string> want_tags = {"some_different_tag"};
+
+		r->enable_tags(want_tags, default_ruleset);
+		REQUIRE(r->enabled_count(non_default_ruleset) == 0);
+	}
+
+	SECTION("Should enable/disable for overlapping tags")
+	{
+		std::set<std::string> want_tags = {"some_tag", "some_different_tag"};
+
+		r->enable_tags(want_tags, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 1);
+
+		r->disable_tags(want_tags, default_ruleset);
+		REQUIRE(r->enabled_count(default_ruleset) == 0);
+	}
+
+}
+
+TEST_CASE("Should enable/disable on ruleset for incremental adding tags", "[rulesets]")
+{
+	auto f = create_factory();
+	auto r = create_ruleset(f);
+	auto ast = create_ast(f);
+
+	auto rule1_filter = create_filter(f, ast);
+	falco_rule rule1;
+	rule1.name = "one_rule";
+	rule1.source = falco_common::syscall_source;
+	rule1.tags =  {"rule1_tag"};
+	r->add(rule1, rule1_filter, ast);
+
+	auto rule2_filter = create_filter(f, ast);
+	falco_rule rule2;
+	rule2.name = "two_rule";
+	rule2.source = falco_common::syscall_source;
+	rule2.tags =  {"rule2_tag"};
+	r->add(rule2, rule2_filter, ast);
+
+	std::set<std::string> want_tags;
+
+	want_tags = rule1.tags;
+	r->enable_tags(want_tags, default_ruleset);
+	REQUIRE(r->enabled_count(default_ruleset) == 1);
+
+	want_tags = rule2.tags;
+	r->enable_tags(want_tags, default_ruleset);
+	REQUIRE(r->enabled_count(default_ruleset) == 2);
+
+	r->disable_tags(want_tags, default_ruleset);
+	REQUIRE(r->enabled_count(default_ruleset) == 1);
+
+	want_tags = rule1.tags;
+	r->disable_tags(want_tags, default_ruleset);
+	REQUIRE(r->enabled_count(default_ruleset) == 0);
+}
--- a/tests/falco/test_configuration.cpp
+++ b/tests/falco/test_configuration.cpp
@@ -0,0 +1,106 @@
+/*
+Copyright (C) 2021 The Falco Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+#include "configuration.h"
+#include <catch.hpp>
+
+string sample_yaml = 
+    "base_value:\n"
+    "    id: 1\n"
+    "    name: 'sample_name'\n"
+    "    subvalue:\n"
+    "      subvalue2:\n"
+    "        boolean: true\n"
+    "base_value_2:\n"
+    "  sample_list:\n"
+    "    - elem1\n"
+    "    - elem2\n"
+    "    - elem3\n"
+;
+
+TEST_CASE("configuration must load YAML data", "[configuration]")
+{
+    yaml_configuration conf;
+
+    SECTION("broken YAML")
+    {
+        string sample_broken_yaml = sample_yaml + " /  bad_symbol";
+        REQUIRE_THROWS(conf.load_from_string(sample_broken_yaml));
+    }
+
+    SECTION("valid YAML")
+    {    
+        REQUIRE_NOTHROW(conf.load_from_string(sample_yaml));
+    }
+
+    SECTION("clearing and reloading")
+    {   
+        conf.load_from_string(sample_yaml);
+        REQUIRE(conf.is_defined("base_value") == true);
+        conf.clear();
+        REQUIRE(conf.is_defined("base_value") == false);
+        conf.load_from_string(sample_yaml);
+        REQUIRE(conf.is_defined("base_value") == true);
+    }
+}
+
+TEST_CASE("configuration must read YAML fields", "[configuration]")
+{
+	yaml_configuration conf;
+    conf.load_from_string(sample_yaml);
+
+    SECTION("base level")
+    {
+        REQUIRE(conf.is_defined("base_value") == true);
+        REQUIRE(conf.is_defined("base_value_2") == true);
+        REQUIRE(conf.is_defined("unknown_base_value") == false);
+    }
+
+    SECTION("arbitrary depth nesting")
+    {
+        REQUIRE(conf.get_scalar<int>("base_value.id", -1) == 1);
+        REQUIRE(conf.get_scalar<string>("base_value.name", "none") == "sample_name");
+        REQUIRE(conf.get_scalar<bool>("base_value.subvalue.subvalue2.boolean", false) == true);
+    }
+    
+    SECTION("list field elements")
+    {
+        REQUIRE(conf.get_scalar<string>("base_value_2.sample_list[0]", "none") == "elem1");
+        REQUIRE(conf.get_scalar<string>("base_value_2.sample_list[1]", "none") == "elem2");
+        REQUIRE(conf.get_scalar<string>("base_value_2.sample_list[2]", "none") == "elem3");
+    }
+
+    SECTION("sequence")
+    {
+        vector<string> seq;
+        conf.get_sequence(seq, "base_value_2.sample_list");
+        REQUIRE(seq.size() == 3);
+        REQUIRE(seq[0] == "elem1");
+        REQUIRE(seq[1] == "elem2");
+        REQUIRE(seq[2] == "elem3");
+    }
+}
+
+TEST_CASE("configuration must modify YAML fields", "[configuration]")
+{
+    string key = "base_value.subvalue.subvalue2.boolean";
+	yaml_configuration conf;
+    conf.load_from_string(sample_yaml);
+    REQUIRE(conf.get_scalar<bool>(key, false) == true);
+    conf.set_scalar<bool>(key, false);
+    REQUIRE(conf.get_scalar<bool>(key, true) == false);
+    conf.set_scalar<bool>(key, true);
+    REQUIRE(conf.get_scalar<bool>(key, false) == true);
+}
--- a/userspace/falco/app/signals.h
+++ b/userspace/falco/app/signals.h
@@ -1,5 +1,5 @@
 /*
-Copyright (C) 2023 The Falco Authors.
+Copyright (C) 2019 The Falco Authors.

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -13,17 +13,10 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
+#define CATCH_CONFIG_MAIN
+#define CATCH_CONFIG_CONSOLE_WIDTH 300
+#include <catch.hpp>

-#pragma once
-
-#include "../atomic_signal_handler.h"
-
-namespace falco {
-namespace app {
-
-extern atomic_signal_handler g_terminate_signal;
-extern atomic_signal_handler g_restart_signal;
-extern atomic_signal_handler g_reopen_outputs_signal;
-
-}; // namespace app
-}; // namespace falco
+TEST_CASE("all test cases reside in other .cpp files (empty)", "[multi-file:1]")
+{
+}
--- a/unit_tests/CMakeLists.txt
+++ b/unit_tests/CMakeLists.txt
@@ -1,64 +0,0 @@
-#
-# Copyright (C) 2023 The Falco Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
-# the License. You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations under the License.
-#
-
-message(STATUS "Falco unit tests build enabled")
-
-include(FetchContent)
-
-FetchContent_Declare(
-  googletest
-  GIT_REPOSITORY https://github.com/google/googletest.git
-  GIT_TAG        release-1.12.1
-)
-
-FetchContent_MakeAvailable(googletest)
-
-file(GLOB_RECURSE ENGINE_TESTS ${CMAKE_CURRENT_SOURCE_DIR}/engine/*.cpp)
-file(GLOB_RECURSE FALCO_TESTS ${CMAKE_CURRENT_SOURCE_DIR}/falco/*.cpp)
-
-set(FALCO_UNIT_TESTS_SOURCES
-  "${ENGINE_TESTS}"
-  "${FALCO_TESTS}"
-)
-
-set(FALCO_UNIT_TESTS_INCLUDES
-    PRIVATE
-    ${CMAKE_SOURCE_DIR}/userspace
-    ${CMAKE_BINARY_DIR}/userspace/falco # we need it to include indirectly `config_falco.h` file
-    ${CMAKE_SOURCE_DIR}/userspace/engine # we need it to include indirectly `falco_common.h` file
-)
-
-set(FALCO_UNIT_TESTS_DEPENDENCIES
-  gtest
-  gtest_main
-  falco_application
-)
-
-get_target_property(FALCO_APPLICATION_LIBRARIES falco_application LINK_LIBRARIES)
-
-set(FALCO_UNIT_TESTS_LIBRARIES
-  gtest
-  gtest_main
-  falco_application
-  ${FALCO_APPLICATION_LIBRARIES}
-)
-
-message(STATUS "FALCO_UNIT_TESTS_SOURCES: ${FALCO_UNIT_TESTS_SOURCES}")
-message(STATUS "FALCO_UNIT_TESTS_INCLUDES: ${FALCO_UNIT_TESTS_INCLUDES}")
-message(STATUS "FALCO_UNIT_TESTS_DEPENDENCIES: ${FALCO_UNIT_TESTS_DEPENDENCIES}")
-message(STATUS "FALCO_UNIT_TESTS_LIBRARIES: ${FALCO_UNIT_TESTS_LIBRARIES}")
-
-add_executable(falco_unit_tests ${FALCO_UNIT_TESTS_SOURCES})
-target_include_directories(falco_unit_tests ${FALCO_UNIT_TESTS_INCLUDES})
-target_link_libraries(falco_unit_tests ${FALCO_UNIT_TESTS_LIBRARIES})
-add_dependencies(falco_unit_tests ${FALCO_UNIT_TESTS_DEPENDENCIES})
--- a/unit_tests/README.md
+++ b/unit_tests/README.md
@@ -1,13 +0,0 @@
-# Falco unit tests
-
-## Intro
-
-Under `unit_tests/engine` and `unit_tests/falco` directories, we have different test suites that could be a single file or an entire directory according to the number and the complexity of tests.
-
-## Build and Run
-
-```bash
-cmake -DMINIMAL_BUILD=On -DBUILD_BPF=Off -DBUILD_DRIVER=Off -DBUILD_FALCO_UNIT_TESTS=On ..
-make falco_unit_tests
-sudo ./unit_tests/falco_unit_tests
-```
--- a/unit_tests/engine/test_falco_utils.cpp
+++ b/unit_tests/engine/test_falco_utils.cpp
@@ -1,38 +0,0 @@
-/*
-Copyright (C) 2023 The Falco Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#include <gtest/gtest.h>
-#include <engine/falco_utils.h>
-
-TEST(FalcoUtils, is_unix_scheme)
-{
-	/* Wrong prefix */
-	ASSERT_EQ(falco::utils::network::is_unix_scheme("something:///run/falco/falco.sock"), false);
-
-	/* Similar prefix, but wrong */
-	ASSERT_EQ(falco::utils::network::is_unix_scheme("unix///falco.sock"), false);
-
-	/* Right prefix, passed as an `rvalue` */
-	ASSERT_EQ(falco::utils::network::is_unix_scheme("unix:///falco.sock"), true);
-
-	/* Right prefix, passed as a `std::string` */
-	std::string url_string("unix:///falco.sock");
-	ASSERT_EQ(falco::utils::network::is_unix_scheme(url_string), true);
-
-	/* Right prefix, passed as a `char[]` */
-	char url_char[] = "unix:///falco.sock";
-	ASSERT_EQ(falco::utils::network::is_unix_scheme(url_char), true);
-}
--- a/unit_tests/engine/test_filter_macro_resolver.cpp
+++ b/unit_tests/engine/test_filter_macro_resolver.cpp
@@ -1,278 +0,0 @@
-/*
-Copyright (C) 2023 The Falco Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless ASSERT_EQd by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#include <gtest/gtest.h>
-#include <engine/filter_macro_resolver.h>
-
-static std::vector<filter_macro_resolver::value_info>::const_iterator find_value(
-	const std::vector<filter_macro_resolver::value_info>& values,
-	const std::string& ref)
-{
-	return std::find_if(
-		values.begin(),
-		values.end(),
-		[&ref](const filter_macro_resolver::value_info& v)
-		{ return v.first == ref; });
-}
-
-#define MACRO_NAME "test_macro"
-#define MACRO_A_NAME "test_macro_1"
-#define MACRO_B_NAME "test_macro_2"
-
-TEST(MacroResolver, should_resolve_macros_on_a_filter_AST)
-{
-	libsinsp::filter::ast::pos_info macro_pos(12, 85, 27);
-
-	std::shared_ptr<libsinsp::filter::ast::expr> macro = std::move(libsinsp::filter::ast::unary_check_expr::create("test.field", "", "exists"));
-
-	std::vector<std::unique_ptr<libsinsp::filter::ast::expr>> filter_and;
-	filter_and.push_back(libsinsp::filter::ast::unary_check_expr::create("evt.name", "", "exists"));
-	filter_and.push_back(libsinsp::filter::ast::not_expr::create(libsinsp::filter::ast::value_expr::create(MACRO_NAME, macro_pos)));
-	std::shared_ptr<libsinsp::filter::ast::expr> filter = std::move(libsinsp::filter::ast::and_expr::create(filter_and));
-
-	std::vector<std::unique_ptr<libsinsp::filter::ast::expr>> expected_and;
-	expected_and.push_back(libsinsp::filter::ast::unary_check_expr::create("evt.name", "", "exists"));
-	expected_and.push_back(libsinsp::filter::ast::not_expr::create(clone(macro.get())));
-	std::shared_ptr<libsinsp::filter::ast::expr> expected = std::move(libsinsp::filter::ast::and_expr::create(expected_and));
-
-	filter_macro_resolver resolver;
-	resolver.set_macro(MACRO_NAME, macro);
-
-	// first run
-	ASSERT_TRUE(resolver.run(filter));
-	ASSERT_EQ(resolver.get_resolved_macros().size(), 1);
-	ASSERT_STREQ(resolver.get_resolved_macros().begin()->first.c_str(), MACRO_NAME);
-	ASSERT_EQ(resolver.get_resolved_macros().begin()->second, macro_pos);
-	ASSERT_TRUE(resolver.get_unknown_macros().empty());
-	ASSERT_TRUE(filter->is_equal(expected.get()));
-
-	// second run
-	ASSERT_FALSE(resolver.run(filter));
-	ASSERT_TRUE(resolver.get_resolved_macros().empty());
-	ASSERT_TRUE(resolver.get_unknown_macros().empty());
-	ASSERT_TRUE(filter->is_equal(expected.get()));
-}
-
-TEST(MacroResolver, should_resolve_macros_on_a_filter_AST_single_node)
-{
-	libsinsp::filter::ast::pos_info macro_pos(12, 85, 27);
-
-	std::shared_ptr<libsinsp::filter::ast::expr> macro = std::move(libsinsp::filter::ast::unary_check_expr::create("test.field", "", "exists"));
-
-	std::shared_ptr<libsinsp::filter::ast::expr> filter = std::move(libsinsp::filter::ast::value_expr::create(MACRO_NAME, macro_pos));
-
-	filter_macro_resolver resolver;
-	resolver.set_macro(MACRO_NAME, macro);
-
-	// first run
-	libsinsp::filter::ast::expr* old_filter_ptr = filter.get();
-	ASSERT_TRUE(resolver.run(filter));
-	ASSERT_NE(filter.get(), old_filter_ptr);
-	ASSERT_EQ(resolver.get_resolved_macros().size(), 1);
-	ASSERT_STREQ(resolver.get_resolved_macros().begin()->first.c_str(), MACRO_NAME);
-	ASSERT_EQ(resolver.get_resolved_macros().begin()->second, macro_pos);
-	ASSERT_TRUE(resolver.get_unknown_macros().empty());
-	ASSERT_TRUE(filter->is_equal(macro.get()));
-
-	// second run
-	old_filter_ptr = filter.get();
-	ASSERT_FALSE(resolver.run(filter));
-	ASSERT_EQ(filter.get(), old_filter_ptr);
-	ASSERT_TRUE(resolver.get_resolved_macros().empty());
-	ASSERT_TRUE(resolver.get_unknown_macros().empty());
-	ASSERT_TRUE(filter->is_equal(macro.get()));
-}
-
-TEST(MacroResolver, should_resolve_macros_on_a_filter_AST_multiple_macros)
-{
-	libsinsp::filter::ast::pos_info a_macro_pos(11, 75, 43);
-	libsinsp::filter::ast::pos_info b_macro_pos(91, 21, 9);
-
-	std::shared_ptr<libsinsp::filter::ast::expr> a_macro = std::move(libsinsp::filter::ast::unary_check_expr::create("one.field", "", "exists"));
-	std::shared_ptr<libsinsp::filter::ast::expr> b_macro = std::move(libsinsp::filter::ast::unary_check_expr::create("another.field", "", "exists"));
-
-	std::vector<std::unique_ptr<libsinsp::filter::ast::expr>> filter_or;
-	filter_or.push_back(libsinsp::filter::ast::value_expr::create(MACRO_A_NAME, a_macro_pos));
-	filter_or.push_back(libsinsp::filter::ast::value_expr::create(MACRO_B_NAME, b_macro_pos));
-	std::shared_ptr<libsinsp::filter::ast::expr> filter = std::move(libsinsp::filter::ast::or_expr::create(filter_or));
-
-	std::vector<std::unique_ptr<libsinsp::filter::ast::expr>> expected_or;
-	expected_or.push_back(clone(a_macro.get()));
-	expected_or.push_back(clone(b_macro.get()));
-	std::shared_ptr<libsinsp::filter::ast::expr> expected_filter = std::move(libsinsp::filter::ast::or_expr::create(expected_or));
-
-	filter_macro_resolver resolver;
-	resolver.set_macro(MACRO_A_NAME, a_macro);
-	resolver.set_macro(MACRO_B_NAME, b_macro);
-
-	// first run
-	ASSERT_TRUE(resolver.run(filter));
-	ASSERT_EQ(resolver.get_resolved_macros().size(), 2);
-	auto a_resolved_itr = find_value(resolver.get_resolved_macros(), MACRO_A_NAME);
-	ASSERT_NE(a_resolved_itr, resolver.get_resolved_macros().end());
-	ASSERT_STREQ(a_resolved_itr->first.c_str(), MACRO_A_NAME);
-	ASSERT_EQ(a_resolved_itr->second, a_macro_pos);
-
-	auto b_resolved_itr = find_value(resolver.get_resolved_macros(), MACRO_B_NAME);
-	ASSERT_NE(b_resolved_itr, resolver.get_resolved_macros().end());
-	ASSERT_TRUE(resolver.get_unknown_macros().empty());
-	ASSERT_STREQ(b_resolved_itr->first.c_str(), MACRO_B_NAME);
-	ASSERT_EQ(b_resolved_itr->second, b_macro_pos);
-	ASSERT_TRUE(filter->is_equal(expected_filter.get()));
-
-	// second run
-	ASSERT_FALSE(resolver.run(filter));
-	ASSERT_TRUE(resolver.get_resolved_macros().empty());
-	ASSERT_TRUE(resolver.get_unknown_macros().empty());
-	ASSERT_TRUE(filter->is_equal(expected_filter.get()));
-}
-
-TEST(MacroResolver, should_resolve_macros_on_a_filter_AST_nested_macros)
-{
-	libsinsp::filter::ast::pos_info a_macro_pos(47, 1, 76);
-	libsinsp::filter::ast::pos_info b_macro_pos(111, 65, 2);
-
-	std::vector<std::unique_ptr<libsinsp::filter::ast::expr>> a_macro_and;
-	a_macro_and.push_back(libsinsp::filter::ast::unary_check_expr::create("one.field", "", "exists"));
-	a_macro_and.push_back(libsinsp::filter::ast::value_expr::create(MACRO_B_NAME, b_macro_pos));
-	std::shared_ptr<libsinsp::filter::ast::expr> a_macro = std::move(libsinsp::filter::ast::and_expr::create(a_macro_and));
-
-	std::shared_ptr<libsinsp::filter::ast::expr> b_macro = std::move(
-		libsinsp::filter::ast::unary_check_expr::create("another.field", "", "exists"));
-
-	std::shared_ptr<libsinsp::filter::ast::expr> filter = std::move(libsinsp::filter::ast::value_expr::create(MACRO_A_NAME, a_macro_pos));
-
-	std::vector<std::unique_ptr<libsinsp::filter::ast::expr>> expected_and;
-	expected_and.push_back(libsinsp::filter::ast::unary_check_expr::create("one.field", "", "exists"));
-	expected_and.push_back(libsinsp::filter::ast::unary_check_expr::create("another.field", "", "exists"));
-	std::shared_ptr<libsinsp::filter::ast::expr> expected_filter = std::move(libsinsp::filter::ast::and_expr::create(expected_and));
-
-	filter_macro_resolver resolver;
-	resolver.set_macro(MACRO_A_NAME, a_macro);
-	resolver.set_macro(MACRO_B_NAME, b_macro);
-
-	// first run
-	ASSERT_TRUE(resolver.run(filter));
-	ASSERT_EQ(resolver.get_resolved_macros().size(), 2);
-	auto a_resolved_itr = find_value(resolver.get_resolved_macros(), MACRO_A_NAME);
-	ASSERT_NE(a_resolved_itr, resolver.get_resolved_macros().end());
-	ASSERT_STREQ(a_resolved_itr->first.c_str(), MACRO_A_NAME);
-	ASSERT_EQ(a_resolved_itr->second, a_macro_pos);
-
-	auto b_resolved_itr = find_value(resolver.get_resolved_macros(), MACRO_B_NAME);
-	ASSERT_NE(b_resolved_itr, resolver.get_resolved_macros().end());
-	ASSERT_TRUE(resolver.get_unknown_macros().empty());
-	ASSERT_STREQ(b_resolved_itr->first.c_str(), MACRO_B_NAME);
-	ASSERT_EQ(b_resolved_itr->second, b_macro_pos);
-
-	ASSERT_TRUE(resolver.get_unknown_macros().empty());
-	ASSERT_TRUE(filter->is_equal(expected_filter.get()));
-
-	// second run
-	ASSERT_FALSE(resolver.run(filter));
-	ASSERT_TRUE(resolver.get_resolved_macros().empty());
-	ASSERT_TRUE(resolver.get_unknown_macros().empty());
-	ASSERT_TRUE(filter->is_equal(expected_filter.get()));
-}
-
-TEST(MacroResolver, should_find_unknown_macros)
-{
-	libsinsp::filter::ast::pos_info macro_pos(9, 4, 2);
-
-	std::vector<std::unique_ptr<libsinsp::filter::ast::expr>> filter_and;
-	filter_and.push_back(libsinsp::filter::ast::unary_check_expr::create("evt.name", "", "exists"));
-	filter_and.push_back(libsinsp::filter::ast::not_expr::create(libsinsp::filter::ast::value_expr::create(MACRO_NAME, macro_pos)));
-	std::shared_ptr<libsinsp::filter::ast::expr> filter = std::move(libsinsp::filter::ast::and_expr::create(filter_and));
-
-	filter_macro_resolver resolver;
-	ASSERT_FALSE(resolver.run(filter));
-	ASSERT_EQ(resolver.get_unknown_macros().size(), 1);
-	ASSERT_STREQ(resolver.get_unknown_macros().begin()->first.c_str(), MACRO_NAME);
-	ASSERT_EQ(resolver.get_unknown_macros().begin()->second, macro_pos);
-	ASSERT_TRUE(resolver.get_resolved_macros().empty());
-}
-
-TEST(MacroResolver, should_find_unknown_nested_macros)
-{
-	libsinsp::filter::ast::pos_info a_macro_pos(32, 84, 9);
-	libsinsp::filter::ast::pos_info b_macro_pos(1, 0, 5);
-
-	std::vector<std::unique_ptr<libsinsp::filter::ast::expr>> a_macro_and;
-	a_macro_and.push_back(libsinsp::filter::ast::unary_check_expr::create("one.field", "", "exists"));
-	a_macro_and.push_back(libsinsp::filter::ast::value_expr::create(MACRO_B_NAME, b_macro_pos));
-	std::shared_ptr<libsinsp::filter::ast::expr> a_macro = std::move(libsinsp::filter::ast::and_expr::create(a_macro_and));
-
-	std::shared_ptr<libsinsp::filter::ast::expr> filter = std::move(libsinsp::filter::ast::value_expr::create(MACRO_A_NAME, a_macro_pos));
-	auto expected_filter = clone(a_macro.get());
-
-	filter_macro_resolver resolver;
-	resolver.set_macro(MACRO_A_NAME, a_macro);
-
-	ASSERT_TRUE(resolver.run(filter));
-	ASSERT_EQ(resolver.get_resolved_macros().size(), 1);
-	ASSERT_STREQ(resolver.get_resolved_macros().begin()->first.c_str(), MACRO_A_NAME);
-	ASSERT_EQ(resolver.get_resolved_macros().begin()->second, a_macro_pos);
-	ASSERT_EQ(resolver.get_unknown_macros().size(), 1);
-	ASSERT_STREQ(resolver.get_unknown_macros().begin()->first.c_str(), MACRO_B_NAME);
-	ASSERT_EQ(resolver.get_unknown_macros().begin()->second, b_macro_pos);
-	ASSERT_TRUE(filter->is_equal(expected_filter.get()));
-}
-
-TEST(MacroResolver, should_undefine_macro)
-{
-	libsinsp::filter::ast::pos_info macro_pos_1(12, 9, 3);
-	libsinsp::filter::ast::pos_info macro_pos_2(9, 6, 3);
-
-	std::shared_ptr<libsinsp::filter::ast::expr> macro = std::move(libsinsp::filter::ast::unary_check_expr::create("test.field", "", "exists"));
-	std::shared_ptr<libsinsp::filter::ast::expr> a_filter = std::move(libsinsp::filter::ast::value_expr::create(MACRO_NAME, macro_pos_1));
-	std::shared_ptr<libsinsp::filter::ast::expr> b_filter = std::move(libsinsp::filter::ast::value_expr::create(MACRO_NAME, macro_pos_2));
-	filter_macro_resolver resolver;
-
-	resolver.set_macro(MACRO_NAME, macro);
-	ASSERT_TRUE(resolver.run(a_filter));
-	ASSERT_EQ(resolver.get_resolved_macros().size(), 1);
-	ASSERT_STREQ(resolver.get_resolved_macros().begin()->first.c_str(), MACRO_NAME);
-	ASSERT_EQ(resolver.get_resolved_macros().begin()->second, macro_pos_1);
-	ASSERT_TRUE(resolver.get_unknown_macros().empty());
-	ASSERT_TRUE(a_filter->is_equal(macro.get()));
-
-	resolver.set_macro(MACRO_NAME, NULL);
-	ASSERT_FALSE(resolver.run(b_filter));
-	ASSERT_TRUE(resolver.get_resolved_macros().empty());
-	ASSERT_EQ(resolver.get_unknown_macros().size(), 1);
-	ASSERT_STREQ(resolver.get_unknown_macros().begin()->first.c_str(), MACRO_NAME);
-	ASSERT_EQ(resolver.get_unknown_macros().begin()->second, macro_pos_2);
-}
-
-/* checks that the macro AST is cloned and not shared across resolved filters */
-TEST(MacroResolver, should_clone_macro_AST)
-{
-	libsinsp::filter::ast::pos_info macro_pos(5, 2, 8888);
-	std::shared_ptr<libsinsp::filter::ast::unary_check_expr> macro = std::move(libsinsp::filter::ast::unary_check_expr::create("test.field", "", "exists"));
-	std::shared_ptr<libsinsp::filter::ast::expr> filter = std::move(libsinsp::filter::ast::value_expr::create(MACRO_NAME, macro_pos));
-	filter_macro_resolver resolver;
-
-	resolver.set_macro(MACRO_NAME, macro);
-	ASSERT_TRUE(resolver.run(filter));
-	ASSERT_EQ(resolver.get_resolved_macros().size(), 1);
-	ASSERT_STREQ(resolver.get_resolved_macros().begin()->first.c_str(), MACRO_NAME);
-	ASSERT_EQ(resolver.get_resolved_macros().begin()->second, macro_pos);
-	ASSERT_TRUE(resolver.get_unknown_macros().empty());
-	ASSERT_TRUE(filter->is_equal(macro.get()));
-
-	macro->field = "another.field";
-	ASSERT_FALSE(filter->is_equal(macro.get()));
-}
--- a/unit_tests/engine/test_filter_warning_resolver.cpp
+++ b/unit_tests/engine/test_filter_warning_resolver.cpp
@@ -1,42 +0,0 @@
-/*
-Copyright (C) 2023 The Falco Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless ASSERTd by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#include <gtest/gtest.h>
-#include <engine/filter_warning_resolver.h>
-
-static bool warns(const std::string& condition)
-{
-	std::set<falco::load_result::warning_code> w;
-	auto ast = libsinsp::filter::parser(condition).parse();
-	filter_warning_resolver().run(ast.get(), w);
-	return !w.empty();
-}
-
-TEST(WarningResolver, warnings_in_filtering_conditions)
-{
-	ASSERT_FALSE(warns("ka.field exists"));
-	ASSERT_FALSE(warns("some.field = <NA>"));
-	ASSERT_TRUE(warns("jevt.field = <NA>"));
-	ASSERT_TRUE(warns("ka.field = <NA>"));
-	ASSERT_TRUE(warns("ka.field == <NA>"));
-	ASSERT_TRUE(warns("ka.field != <NA>"));
-	ASSERT_TRUE(warns("ka.field in (<NA>)"));
-	ASSERT_TRUE(warns("ka.field in (otherval, <NA>)"));
-	ASSERT_TRUE(warns("ka.field intersects (<NA>)"));
-	ASSERT_TRUE(warns("ka.field intersects (otherval, <NA>)"));
-	ASSERT_TRUE(warns("ka.field pmatch (<NA>)"));
-	ASSERT_TRUE(warns("ka.field pmatch (otherval, <NA>)"));
-}
--- a/unit_tests/engine/test_plugin_requirements.cpp
+++ b/unit_tests/engine/test_plugin_requirements.cpp
@@ -1,238 +0,0 @@
-/*
-Copyright (C) 2023 The Falco Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#include <memory>
-#include <engine/falco_engine.h>
-#include <gtest/gtest.h>
-
-static bool check_requirements(std::string& err,
-			       const std::vector<falco_engine::plugin_version_requirement>& plugins,
-			       const std::string& ruleset_content)
-{
-	std::unique_ptr<falco_engine> e(new falco_engine());
-	falco::load_result::rules_contents_t c = {{"test", ruleset_content}};
-
-	auto res = e->load_rules(c.begin()->second, c.begin()->first);
-	if(!res->successful())
-	{
-		return false;
-	}
-	return e->check_plugin_requirements(plugins, err);
-}
-
-TEST(PluginRequirements, check_plugin_requirements_success)
-{
-	std::string error;
-
-	/* No requirement */
-	ASSERT_TRUE(check_requirements(error, {{"k8saudit", "0.1.0"}}, "")) << error << std::endl;
-
-	/* Single plugin */
-	ASSERT_TRUE(check_requirements(error, {{"k8saudit", "0.1.0"}}, R"(
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.1.0
-        )")) << error
-	     << std::endl;
-
-	/* Single plugin newer version */
-	ASSERT_TRUE(check_requirements(error, {{"k8saudit", "0.2.0"}}, R"(
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.1.0
-        )")) << error
-	     << std::endl;
-
-	/* Multiple plugins */
-	ASSERT_TRUE(check_requirements(error, {{"k8saudit", "0.1.0"}, {"json", "0.3.0"}}, R"(
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.1.0
-  - name: json
-    version: 0.3.0
-        )")) << error
-	     << std::endl;
-
-	/* Single plugin multiple versions */
-	ASSERT_TRUE(check_requirements(error, {{"k8saudit", "0.2.0"}}, R"(
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.1.0
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.2.0
-        )")) << error
-	     << std::endl;
-
-	/* Single plugin with alternatives */
-	ASSERT_TRUE(check_requirements(error, {{"k8saudit-other", "0.5.0"}}, R"(
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.1.0
-    alternatives:
-      - name: k8saudit-other
-        version: 0.4.0
-        )")) << error
-	     << std::endl;
-
-	/* Multiple plugins with alternatives */
-	ASSERT_TRUE(check_requirements(error, {{"k8saudit-other", "0.5.0"}, {"json2", "0.5.0"}}, R"(
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.1.0
-    alternatives:
-      - name: k8saudit-other
-        version: 0.4.0
-  - name: json
-    version: 0.3.0
-    alternatives:
-      - name: json2
-        version: 0.1.0
-        )")) << error
-	     << std::endl;
-
-	/* Multiple plugins with alternatives with multiple versions */
-	ASSERT_TRUE(check_requirements(error, {{"k8saudit-other", "0.7.0"}, {"json2", "0.5.0"}}, R"(
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.1.0
-    alternatives:
-      - name: k8saudit-other
-        version: 0.4.0
-  - name: json
-    version: 0.3.0
-    alternatives:
-      - name: json2
-        version: 0.1.0
- required_plugin_versions:
-  - name: k8saudit
-    version: 1.0.0
-    alternatives:
-      - name: k8saudit-other
-        version: 0.7.0
-        )")) << error
-	     << std::endl;
-}
-
-TEST(PluginRequirements, check_plugin_requirements_reject)
-{
-	std::string error;
-
-	/* No plugin loaded */
-	ASSERT_FALSE(check_requirements(error, {}, R"(
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.1.0
-        )")) << error
-	     << std::endl;
-
-	/* Single plugin wrong name */
-	ASSERT_FALSE(check_requirements(error, {{"k8saudit", "0.1.0"}}, R"(
- required_plugin_versions:
-  - name: k8saudit2
-    version: 0.1.0
-        )")) << error
-	     << std::endl;
-
-	/* Single plugin wrong version */
-	ASSERT_FALSE(check_requirements(error, {{"k8saudit", "0.1.0"}}, R"(
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.2.0
-        )")) << error
-	     << std::endl;
-
-	/* Multiple plugins */
-	ASSERT_FALSE(check_requirements(error, {{"k8saudit", "0.1.0"}}, R"(
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.1.0
-  - name: json
-    version: 0.3.0
-        )")) << error
-	     << std::endl;
-
-	/* Single plugin multiple versions */
-	ASSERT_FALSE(check_requirements(error, {{"k8saudit", "0.1.0"}}, R"(
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.1.0
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.2.0
-        )")) << error
-	     << std::endl;
-
-	/* Single plugin with alternatives */
-	ASSERT_FALSE(check_requirements(error, {{"k8saudit2", "0.5.0"}}, R"(
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.1.0
-    alternatives:
-      - name: k8saudit-other
-        version: 0.4.0
-        )")) << error
-	     << std::endl;
-
-	/* Single plugin with overlapping alternatives */
-	ASSERT_FALSE(check_requirements(error, {{"k8saudit", "0.5.0"}}, R"(
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.1.0
-    alternatives:
-      - name: k8saudit
-        version: 0.4.0
-        )")) << error
-	     << std::endl;
-
-	/* Multiple plugins with alternatives */
-	ASSERT_FALSE(check_requirements(error, {{"k8saudit-other", "0.5.0"}, {"json3", "0.5.0"}}, R"(
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.1.0
-    alternatives:
-      - name: k8saudit-other
-        version: 0.4.0
-  - name: json
-    version: 0.3.0
-    alternatives:
-      - name: json2
-        version: 0.1.0
-        )")) << error
-	     << std::endl;
-
-	/* Multiple plugins with alternatives with multiple versions */
-	ASSERT_FALSE(check_requirements(error, {{"k8saudit", "0.7.0"}, {"json2", "0.5.0"}}, R"(
- required_plugin_versions:
-  - name: k8saudit
-    version: 0.4.0
-    alternatives:
-      - name: k8saudit-other
-        version: 0.4.0
-  - name: json
-    version: 0.3.0
-    alternatives:
-      - name: json2
-        version: 0.1.0
- required_plugin_versions:
-  - name: k8saudit
-    version: 1.0.0
-    alternatives:
-      - name: k8saudit-other
-        version: 0.7.0
-        )")) << error
-	     << std::endl;
-}
--- a/unit_tests/engine/test_rulesets.cpp
+++ b/unit_tests/engine/test_rulesets.cpp
@@ -1,177 +0,0 @@
-/*
-Copyright (C) 2023 The Falco Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#include <gtest/gtest.h>
-#include <engine/evttype_index_ruleset.h>
-
-#define RULESET_0 0
-#define RULESET_1 1
-#define RULESET_2 2
-
-/* Helpers methods */
-static std::shared_ptr<gen_event_filter_factory> create_factory()
-{
-	std::shared_ptr<gen_event_filter_factory> ret(new sinsp_filter_factory(NULL));
-	return ret;
-}
-
-static std::shared_ptr<filter_ruleset> create_ruleset(std::shared_ptr<gen_event_filter_factory> f)
-{
-	std::shared_ptr<filter_ruleset> ret(new evttype_index_ruleset(f));
-	return ret;
-}
-
-static std::shared_ptr<libsinsp::filter::ast::expr> create_ast(std::shared_ptr<gen_event_filter_factory> f)
-{
-	libsinsp::filter::parser parser("evt.type=open");
-	std::shared_ptr<libsinsp::filter::ast::expr> ret(parser.parse());
-	return ret;
-}
-
-static std::shared_ptr<gen_event_filter> create_filter(
-	std::shared_ptr<gen_event_filter_factory> f,
-	std::shared_ptr<libsinsp::filter::ast::expr> ast)
-{
-	sinsp_filter_compiler compiler(f, ast.get());
-	std::shared_ptr<gen_event_filter> filter(compiler.compile());
-	return filter;
-}
-
-TEST(Ruleset, enable_disable_rules_using_names)
-{
-	auto f = create_factory();
-	auto r = create_ruleset(f);
-	auto ast = create_ast(f);
-	auto filter = create_filter(f, ast);
-
-	falco_rule rule_A = {};
-	rule_A.name = "rule_A";
-	rule_A.source = falco_common::syscall_source;
-
-	falco_rule rule_B = {};
-	rule_B.name = "rule_B";
-	rule_B.source = falco_common::syscall_source;
-
-	falco_rule rule_C = {};
-	rule_C.name = "rule_C";
-	rule_C.source = falco_common::syscall_source;
-
-	r->add(rule_A, filter, ast);
-	r->add(rule_B, filter, ast);
-	r->add(rule_C, filter, ast);
-
-	/* Enable `rule_A` for RULESET_0 */
-	r->enable(rule_A.name, true, RULESET_0);
-	ASSERT_EQ(r->enabled_count(RULESET_0), 1);
-	ASSERT_EQ(r->enabled_count(RULESET_1), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_2), 0);
-
-	/* Disable `rule_A` for RULESET_1, this should have no effect */
-	r->disable(rule_A.name, true, RULESET_1);
-	ASSERT_EQ(r->enabled_count(RULESET_0), 1);
-	ASSERT_EQ(r->enabled_count(RULESET_1), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_2), 0);
-
-	/* Enable a not existing rule for RULESET_2, this should have no effect */
-	r->disable("<NA>", true, RULESET_2);
-	ASSERT_EQ(r->enabled_count(RULESET_0), 1);
-	ASSERT_EQ(r->enabled_count(RULESET_1), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_2), 0);
-
-	/* Enable all rules for RULESET_0 */
-	r->enable("rule_", false, RULESET_0);
-	ASSERT_EQ(r->enabled_count(RULESET_0), 3);
-	ASSERT_EQ(r->enabled_count(RULESET_1), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_2), 0);
-
-	/* Try to disable all rules with exact match for RULESET_0, this should have no effect */
-	r->disable("rule_", true, RULESET_0);
-	ASSERT_EQ(r->enabled_count(RULESET_0), 3);
-	ASSERT_EQ(r->enabled_count(RULESET_1), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_2), 0);
-
-	/* Disable all rules for RULESET_0 */
-	r->disable("rule_", false, RULESET_0);
-	ASSERT_EQ(r->enabled_count(RULESET_0), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_1), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_2), 0);
-
-	/* Enable rule_C for RULESET_2 without exact_match */
-	r->enable("_C", false, RULESET_2);
-	ASSERT_EQ(r->enabled_count(RULESET_0), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_1), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_2), 1);
-}
-
-TEST(Ruleset, enable_disable_rules_using_tags)
-{
-	auto f = create_factory();
-	auto r = create_ruleset(f);
-	auto ast = create_ast(f);
-	auto filter = create_filter(f, ast);
-
-	falco_rule rule_A = {};
-	rule_A.name = "rule_A";
-	rule_A.source = falco_common::syscall_source;
-	rule_A.tags = {"first_rule_A_tag", "second_rule_A_tag", "common_tag"};
-
-	falco_rule rule_B = {};
-	rule_B.name = "rule_B";
-	rule_B.source = falco_common::syscall_source;
-	rule_B.tags = {"first_rule_B_tag", "second_rule_B_tag", "common_tag"};
-
-	r->add(rule_A, filter, ast);
-	r->add(rule_B, filter, ast);
-
-	/* Enable `rule_A` for RULESET_0 using its first tag */
-	r->enable_tags({"first_rule_A_tag"}, RULESET_0);
-	ASSERT_EQ(r->enabled_count(RULESET_0), 1);
-	ASSERT_EQ(r->enabled_count(RULESET_1), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_2), 0);
-
-	/* Disable `rule_A` for RULESET_1 using its first tag, this should have no effect */
-	r->disable_tags({"first_rule_A_tag"}, RULESET_1);
-	ASSERT_EQ(r->enabled_count(RULESET_0), 1);
-	ASSERT_EQ(r->enabled_count(RULESET_1), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_2), 0);
-
-	/* Enable a not existing rule for RULESET_0, this should have no effect */
-	r->enable_tags({"<NA_tag>"}, RULESET_0);
-	ASSERT_EQ(r->enabled_count(RULESET_0), 1);
-	ASSERT_EQ(r->enabled_count(RULESET_1), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_2), 0);
-
-	/* Enable all rules for RULESET_2 */
-	r->enable_tags({"common_tag"}, RULESET_2);
-	ASSERT_EQ(r->enabled_count(RULESET_0), 1);
-	ASSERT_EQ(r->enabled_count(RULESET_1), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_2), 2);
-
-	/* Disable `rule_A` for RULESET_0 using its second tag
-	 * Note that we have previously enabled it using the first tag,
-	 * so here we are using a different tag of the rule t disable it!
-	 */
-	r->disable_tags({"second_rule_A_tag"}, RULESET_0);
-	ASSERT_EQ(r->enabled_count(RULESET_0), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_1), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_2), 2);
-
-	/* Disable all rules for RULESET_2 */
-	r->disable_tags({"common_tag"}, RULESET_2);
-	ASSERT_EQ(r->enabled_count(RULESET_0), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_1), 0);
-	ASSERT_EQ(r->enabled_count(RULESET_2), 0);
-}
--- a/unit_tests/falco/app/actions/test_configure_interesting_sets.cpp
+++ b/unit_tests/falco/app/actions/test_configure_interesting_sets.cpp
@@ -1,431 +0,0 @@
-/*
-Copyright (C) 2023 The Falco Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-*/
-
-#include <falco_engine.h>
-
-#include <falco/app/app.h>
-#include <falco/app/state.h>
-#include <falco/app/actions/actions.h>
-
-#include <gtest/gtest.h>
-
-#define ASSERT_NAMES_EQ(a, b) { \
-	EXPECT_EQ(_order(a).size(), _order(b).size()); \
-	ASSERT_EQ(_order(a), _order(b)); \
-}
-
-#define ASSERT_NAMES_CONTAIN(a, b) { \
-	ASSERT_NAMES_EQ(unordered_set_intersection(a, b), b); \
-}
-
-#define ASSERT_NAMES_NOCONTAIN(a, b) { \
-	ASSERT_NAMES_EQ(unordered_set_intersection(a, b), strset_t({})); \
-}
-
-using strset_t = std::unordered_set<std::string>;
-
-static std::set<std::string> _order(const strset_t& s) 
-{
-	return std::set<std::string>(s.begin(), s.end());
-}
-
-static std::string s_sample_ruleset = "sample-ruleset";
-
-static std::string s_sample_source = falco_common::syscall_source;
-
-static strset_t s_sample_filters = {
-	"evt.type=connect or evt.type=accept or evt.type=accept4 or evt.type=umount2",
-	"evt.type in (open, ptrace, mmap, execve, read, container)",
-	"evt.type in (open, execve, mprotect) and not evt.type=mprotect"};
-
-static strset_t s_sample_generic_filters = {
-	"evt.type=syncfs or evt.type=fanotify_init"};
-
-static strset_t s_sample_nonsyscall_filters = {
-	"evt.type in (procexit, switch, pluginevent, container)"};
-
-
-// todo(jasondellaluce): once we have deeper and more modular
-// control on the falco engine, make this a little nicer
-static std::shared_ptr<falco_engine> mock_engine_from_filters(const strset_t& filters)
-{
-	// craft a fake ruleset with the given filters
-	int n_rules = 0;
-	std::string dummy_rules;
-	falco::load_result::rules_contents_t content = {{"dummy_rules.yaml", dummy_rules}};
-	for (const auto& f : filters)
-	{
-		n_rules++;
-		dummy_rules +=
-			"- rule: Dummy Rule " + std::to_string(n_rules) + "\n"
-			+ "  output: Dummy Output " + std::to_string(n_rules) + "\n"
-			+ "  condition: " + f + "\n"
-			+ "  desc: Dummy Desc " + std::to_string(n_rules) + "\n"
-			+ "  priority: CRITICAL\n\n";
-	}
-
-	// create a falco engine and load the ruleset
-	std::shared_ptr<falco_engine> res(new falco_engine());
-	auto filter_factory = std::shared_ptr<gen_event_filter_factory>(
-			new sinsp_filter_factory(nullptr));
-	auto formatter_factory = std::shared_ptr<gen_event_formatter_factory>(
-			new sinsp_evt_formatter_factory(nullptr));
-	res->add_source(s_sample_source, filter_factory, formatter_factory);
-	res->load_rules(dummy_rules, "dummy_rules.yaml");
-	res->enable_rule("", true, s_sample_ruleset);
-	return res;
-}
-
-TEST(ConfigureInterestingSets, engine_codes_syscalls_set)
-{
-
-	auto engine = mock_engine_from_filters(s_sample_filters);
-	auto enabled_count = engine->num_rules_for_ruleset(s_sample_ruleset);
-	ASSERT_EQ(enabled_count, s_sample_filters.size());
-
-	// test if event code names were extracted from each rule in test ruleset.
-	auto rules_event_set = engine->event_codes_for_ruleset(s_sample_source);
-	auto rules_event_names = libsinsp::events::event_set_to_names(rules_event_set);
-	ASSERT_NAMES_EQ(rules_event_names, strset_t({
-		"connect", "accept", "accept4", "umount2", "open", "ptrace", "mmap", "execve", "read", "container", "asyncevent"}));
-
-	// test if sc code names were extracted from each rule in test ruleset.
-	// note, this is not supposed to contain "container", as that's an event
-	// not mapped through the ppm_sc_code enumerative.
-	auto rules_sc_set = engine->sc_codes_for_ruleset(s_sample_source);
-	auto rules_sc_names = libsinsp::events::sc_set_to_event_names(rules_sc_set);
-	ASSERT_NAMES_EQ(rules_sc_names, strset_t({
-		"connect", "accept", "accept4", "umount2", "open", "ptrace", "mmap", "execve", "read"}));
-}
-
-TEST(ConfigureInterestingSets, preconditions_postconditions)
-{
-	auto mock_engine = mock_engine_from_filters(s_sample_filters);
-	falco::app::state s1;
-
-	s1.engine = mock_engine;
-	s1.config = nullptr;
-	auto result = falco::app::actions::configure_interesting_sets(s1);
-	ASSERT_FALSE(result.success);
-	ASSERT_NE(result.errstr, "");
-
-	s1.engine = nullptr;
-	s1.config = std::make_shared<falco_configuration>();
-	result = falco::app::actions::configure_interesting_sets(s1);
-	ASSERT_FALSE(result.success);
-	ASSERT_NE(result.errstr, "");
-
-	s1.engine = mock_engine;
-	s1.config = std::make_shared<falco_configuration>();
-	result = falco::app::actions::configure_interesting_sets(s1);
-	ASSERT_TRUE(result.success);
-	ASSERT_EQ(result.errstr, "");
-
-	auto prev_selection_size = s1.selected_sc_set.size();
-	result = falco::app::actions::configure_interesting_sets(s1);
-	ASSERT_TRUE(result.success);
-	ASSERT_EQ(result.errstr, "");
-	ASSERT_EQ(prev_selection_size, s1.selected_sc_set.size());
-}
-
-TEST(ConfigureInterestingSets, engine_codes_nonsyscalls_set)
-{
-	auto filters = s_sample_filters;
-	filters.insert(s_sample_generic_filters.begin(), s_sample_generic_filters.end());
-	filters.insert(s_sample_nonsyscall_filters.begin(), s_sample_nonsyscall_filters.end());
-
-	auto engine = mock_engine_from_filters(filters);
-	auto enabled_count = engine->num_rules_for_ruleset(s_sample_ruleset);
-	ASSERT_EQ(enabled_count, filters.size());
-
-	auto rules_event_set = engine->event_codes_for_ruleset(s_sample_source);
-	auto rules_event_names = libsinsp::events::event_set_to_names(rules_event_set);
-	// note: including even one generic event will cause PPME_GENERIC_E to be
-	// included in the ruleset's event codes. As such, when translating to names,
-	// PPME_GENERIC_E will cause all names of generic events to be added!
-	// This is a good example of information loss from ppm_event_code <-> ppm_sc_code.
-	auto generic_names = libsinsp::events::event_set_to_names({ppm_event_code::PPME_GENERIC_E});
-	auto expected_names = strset_t({
-		"connect", "accept", "accept4", "umount2", "open", "ptrace", "mmap", "execve", "read", "container", // ruleset
-		"procexit", "switch", "pluginevent", "asyncevent"}); // from non-syscall event filters
-	expected_names.insert(generic_names.begin(), generic_names.end());
-	ASSERT_NAMES_EQ(rules_event_names, expected_names);
-
-	auto rules_sc_set = engine->sc_codes_for_ruleset(s_sample_source);
-	auto rules_sc_names = libsinsp::events::sc_set_to_event_names(rules_sc_set);
-	ASSERT_NAMES_EQ(rules_sc_names, strset_t({
-		"connect", "accept", "accept4", "umount2", "open", "ptrace", "mmap", "execve", "read",
-		"procexit", "switch", "syncfs", "fanotify_init", // from generic event filters
-	}));
-}
-
-TEST(ConfigureInterestingSets, selection_not_allevents)
-{
-	falco::app::state s2;
-	// run app action with fake engine and without the `-A` option
-	s2.engine = mock_engine_from_filters(s_sample_filters);
-	s2.options.all_events = false;
-
-	ASSERT_EQ(s2.options.all_events, false);
-	auto result = falco::app::actions::configure_interesting_sets(s2);
-	ASSERT_TRUE(result.success);
-	ASSERT_EQ(result.errstr, "");
-
-	// todo(jasondellaluce): once we have deeper control on falco's outputs,
-	// also check if a warning has been printed in stderr
-
-	// check that the final selected set is the one expected
-	ASSERT_GT(s2.selected_sc_set.size(), 1);
-	auto selected_sc_names = libsinsp::events::sc_set_to_event_names(s2.selected_sc_set);
-	auto expected_sc_names = strset_t({
-		// note: we expect the "read" syscall to have been erased
-		"connect", "accept", "accept4", "umount2", "open", "ptrace", "mmap", "execve", // from ruleset
-		"clone", "clone3", "fork", "vfork", // from sinsp state set (spawned_process)
-		"socket", "bind", "close" // from sinsp state set (network, files)
-	});
-	ASSERT_NAMES_CONTAIN(selected_sc_names, expected_sc_names);
-
-	// check that all IO syscalls have been erased from the selection
-	auto ignored_set = falco::app::ignored_sc_set();
-	auto erased_sc_names = libsinsp::events::sc_set_to_event_names(ignored_set);
-	ASSERT_NAMES_NOCONTAIN(selected_sc_names, erased_sc_names);
-
-	// check that final selected set is exactly sinsp state + ruleset
-	auto rule_set = s2.engine->sc_codes_for_ruleset(s_sample_source, s_sample_ruleset);
-	auto state_set = libsinsp::events::sinsp_state_sc_set();
-	for (const auto &erased : ignored_set)
-	{
-		rule_set.remove(erased);
-		state_set.remove(erased);
-	}
-	auto union_set = state_set.merge(rule_set);
-	auto inter_set = state_set.intersect(rule_set);
-	EXPECT_EQ(s2.selected_sc_set.size(), state_set.size() + rule_set.size() - inter_set.size());
-	ASSERT_EQ(s2.selected_sc_set, union_set);
-}
-
-TEST(ConfigureInterestingSets, selection_allevents)
-{
-	falco::app::state s3;
-	// run app action with fake engine and with the `-A` option
-	s3.engine = mock_engine_from_filters(s_sample_filters);
-	s3.options.all_events = true;
-	auto result = falco::app::actions::configure_interesting_sets(s3);
-	ASSERT_TRUE(result.success);
-	ASSERT_EQ(result.errstr, "");
-
-	// todo(jasondellaluce): once we have deeper control on falco's outputs,
-	// also check if a warning has not been printed in stderr
-
-	// check that the final selected set is the one expected
-	ASSERT_GT(s3.selected_sc_set.size(), 1);
-	auto selected_sc_names = libsinsp::events::sc_set_to_event_names(s3.selected_sc_set);
-	auto expected_sc_names = strset_t({
-		// note: we expect the "read" syscall to not be erased
-		"connect", "accept", "accept4", "umount2", "open", "ptrace", "mmap", "execve", "read", // from ruleset
-		"clone", "clone3", "fork", "vfork", // from sinsp state set (spawned_process)
-		"socket", "bind", "close" // from sinsp state set (network, files)
-	});
-	ASSERT_NAMES_CONTAIN(selected_sc_names, expected_sc_names);
-
-	// check that final selected set is exactly sinsp state + ruleset
-	auto rule_set = s3.engine->sc_codes_for_ruleset(s_sample_source, s_sample_ruleset);
-	auto state_set = libsinsp::events::sinsp_state_sc_set();
-	auto union_set = state_set.merge(rule_set);
-	auto inter_set = state_set.intersect(rule_set);
-	EXPECT_EQ(s3.selected_sc_set.size(), state_set.size() + rule_set.size() - inter_set.size());
-	ASSERT_EQ(s3.selected_sc_set, union_set);
-}
-
-TEST(ConfigureInterestingSets, selection_generic_evts)
-{
-	falco::app::state s4;
-	// run app action with fake engine and without the `-A` option
-	s4.options.all_events = false;
-	auto filters = s_sample_filters;
-	filters.insert(s_sample_generic_filters.begin(), s_sample_generic_filters.end());
-	s4.engine = mock_engine_from_filters(filters);
-	auto result = falco::app::actions::configure_interesting_sets(s4);
-	ASSERT_TRUE(result.success);
-	ASSERT_EQ(result.errstr, "");
-
-	// check that the final selected set is the one expected
-	ASSERT_GT(s4.selected_sc_set.size(), 1);
-	auto selected_sc_names = libsinsp::events::sc_set_to_event_names(s4.selected_sc_set);
-	auto expected_sc_names = strset_t({
-		// note: we expect the "read" syscall to not be erased
-		"connect", "accept", "accept4", "umount2", "open", "ptrace", "mmap", "execve", // from ruleset
-		"syncfs", "fanotify_init",  // from ruleset (generic events)
-		"clone", "clone3", "fork", "vfork", // from sinsp state set (spawned_process)
-		"socket", "bind", "close" // from sinsp state set (network, files)
-	});
-	ASSERT_NAMES_CONTAIN(selected_sc_names, expected_sc_names);
-	auto unexpected_sc_names = libsinsp::events::sc_set_to_event_names(falco::app::ignored_sc_set());
-	ASSERT_NAMES_NOCONTAIN(selected_sc_names, unexpected_sc_names);
-}
-
-// expected combinations precedence:
-// - final selected set is the union of rules events and base events
-//   (either default or custom positive set)
-// - events in the custom negative set are removed from the selected set
-// - if `-A` is not set, events from the IO set are removed from the selected set
-TEST(ConfigureInterestingSets, selection_custom_base_set)
-{
-	falco::app::state s5;
-	// run app action with fake engine and without the `-A` option
-	s5.options.all_events = true;
-	s5.engine = mock_engine_from_filters(s_sample_filters);
-	auto default_base_set = libsinsp::events::sinsp_state_sc_set();
-
-	// non-empty custom base set (both positive and negative)
-	s5.config->m_base_syscalls_repair = false;
-	s5.config->m_base_syscalls_custom_set = {"syncfs", "!accept"};
-	auto result = falco::app::actions::configure_interesting_sets(s5);
-	ASSERT_TRUE(result.success);
-	ASSERT_EQ(result.errstr, "");
-	auto selected_sc_names = libsinsp::events::sc_set_to_event_names(s5.selected_sc_set);
-	auto expected_sc_names = strset_t({
-		// note: `syncfs` has been added due to the custom base set, and `accept`
-		// has been remove due to the negative base set.
-		// note: `read` is not ignored due to the "-A" option being set.
-		// note: `accept` is not included even though it is matched by the rules,
-		// which means that the custom negation base set has precedence over the
-		// final selection set as a whole
-		// note(jasondellaluce): "accept4" should be added, however old versions
-		// of the ACCEPT4 event are actually named "accept" in the event table
-		"connect", "umount2", "open", "ptrace", "mmap", "execve", "read", "syncfs", "procexit"
-	});
-	ASSERT_NAMES_EQ(selected_sc_names, expected_sc_names);
-
-	// non-empty custom base set (both positive and negative with collision)
-	s5.config->m_base_syscalls_repair = false;
-	s5.config->m_base_syscalls_custom_set = {"syncfs", "accept", "!accept"};
-	result = falco::app::actions::configure_interesting_sets(s5);
-	ASSERT_TRUE(result.success);
-	ASSERT_EQ(result.errstr, "");
-	selected_sc_names = libsinsp::events::sc_set_to_event_names(s5.selected_sc_set);
-	// note: in case of collision, negation has priority, so the expected
-	// names are the same as the case above
-	ASSERT_NAMES_EQ(selected_sc_names, expected_sc_names);
-
-	// non-empty custom base set (only positive)
-	s5.config->m_base_syscalls_custom_set = {"syncfs"};
-	result = falco::app::actions::configure_interesting_sets(s5);
-	ASSERT_TRUE(result.success);
-	ASSERT_EQ(result.errstr, "");
-	selected_sc_names = libsinsp::events::sc_set_to_event_names(s5.selected_sc_set);
-	expected_sc_names = strset_t({
-		// note: accept is not negated anymore
-		"connect", "accept", "accept4", "umount2", "open", "ptrace", "mmap", "execve", "read", "syncfs", "procexit"
-	});
-	ASSERT_NAMES_EQ(selected_sc_names, expected_sc_names);
-
-	// non-empty custom base set (only negative)
-	s5.config->m_base_syscalls_custom_set = {"!accept"};
-	result = falco::app::actions::configure_interesting_sets(s5);
-	ASSERT_TRUE(result.success);
-	ASSERT_EQ(result.errstr, "");
-	selected_sc_names = libsinsp::events::sc_set_to_event_names(s5.selected_sc_set);
-	expected_sc_names = unordered_set_union(
-		libsinsp::events::sc_set_to_event_names(default_base_set),
-		strset_t({ "connect", "umount2", "open", "ptrace", "mmap", "execve", "read"}));
-	expected_sc_names.erase("accept");
-	// note(jasondellaluce): "accept4" should be included, however old versions
-	// of the ACCEPT4 event are actually named "accept" in the event table
-	expected_sc_names.erase("accept4");
-	ASSERT_NAMES_EQ(selected_sc_names, expected_sc_names);
-
-	// non-empty custom base set (positive, without -A)
-	s5.options.all_events = false;
-	s5.config->m_base_syscalls_custom_set = {"read"};
-	result = falco::app::actions::configure_interesting_sets(s5);
-	ASSERT_TRUE(result.success);
-	ASSERT_EQ(result.errstr, "");
-	selected_sc_names = libsinsp::events::sc_set_to_event_names(s5.selected_sc_set);
-	expected_sc_names = strset_t({
-		// note: read is both part of the custom base set and the rules set,
-		// but we expect the unset -A option to take precedence
-		"connect", "accept", "accept4", "umount2", "open", "ptrace", "mmap", "execve", "procexit"
-	});
-	ASSERT_NAMES_EQ(selected_sc_names, expected_sc_names);
-	auto unexpected_sc_names = libsinsp::events::sc_set_to_event_names(falco::app::ignored_sc_set());
-	ASSERT_NAMES_NOCONTAIN(selected_sc_names, unexpected_sc_names);
-}
-
-TEST(ConfigureInterestingSets, selection_custom_base_set_repair)
-{
-	falco::app::state s6;
-	// run app action with fake engine and without the `-A` option
-	s6.options.all_events = false;
-	s6.engine = mock_engine_from_filters(s_sample_filters);
-
-	// note: here we use file syscalls (e.g. open, openat) and have a custom
-	// positive set, so we expect syscalls such as "close" to be selected as
-	// repaired. Also, given that we use some network syscalls, we expect "bind"
-	// to be selected event if we negate it, because repairment should have
-	// take precedence.
-	s6.config->m_base_syscalls_custom_set = {"openat", "!bind"};
-	s6.config->m_base_syscalls_repair = true;
-	auto result = falco::app::actions::configure_interesting_sets(s6);
-	ASSERT_TRUE(result.success);
-	ASSERT_EQ(result.errstr, "");
-	auto selected_sc_names = libsinsp::events::sc_set_to_event_names(s6.selected_sc_set);
-	auto expected_sc_names = strset_t({
-		// note: expecting syscalls from mock rules and `sinsp_repair_state_sc_set` enforced syscalls
-		"connect", "accept", "accept4", "umount2", "open", "ptrace", "mmap", "execve", "procexit", \
-		"bind", "socket", "clone3", "close", "setuid"
-	});
-	ASSERT_NAMES_CONTAIN(selected_sc_names, expected_sc_names);
-	auto unexpected_sc_names = libsinsp::events::sc_set_to_event_names(falco::app::ignored_sc_set());
-	ASSERT_NAMES_NOCONTAIN(selected_sc_names, unexpected_sc_names);
-}
-
-TEST(ConfigureInterestingSets, selection_empty_custom_base_set_repair)
-{
-	falco::app::state s7;
-	// run app action with fake engine and with the `-A` option
-	s7.options.all_events = true;
-	s7.engine = mock_engine_from_filters(s_sample_filters);
-
-	// simulate empty custom set but repair option set.
-	s7.config->m_base_syscalls_custom_set = {};
-	s7.config->m_base_syscalls_repair = true;
-	auto result = falco::app::actions::configure_interesting_sets(s7);
-	auto s7_rules_set = s7.engine->sc_codes_for_ruleset(s_sample_source, s_sample_ruleset);
-	ASSERT_TRUE(result.success);
-	ASSERT_EQ(result.errstr, "");
-	auto selected_sc_names = libsinsp::events::sc_set_to_event_names(s7.selected_sc_set);
-	auto expected_sc_names = strset_t({
-		// note: expecting syscalls from mock rules and `sinsp_repair_state_sc_set` enforced syscalls
-		"connect", "accept", "accept4", "umount2", "open", "ptrace", "mmap", "execve", "procexit", \
-		"bind", "socket", "clone3", "close", "setuid"
-	});
-	ASSERT_NAMES_CONTAIN(selected_sc_names, expected_sc_names);
-	auto s7_state_set = libsinsp::events::sinsp_repair_state_sc_set(s7_rules_set);
-	ASSERT_EQ(s7.selected_sc_set, s7_state_set);
-	ASSERT_EQ(s7.selected_sc_set.size(), s7_state_set.size());
-}
-
-TEST(ConfigureInterestingSets, ignored_set_expected_size)
-{
-	// unit test fence to make sure we don't have unexpected regressions
-	// in the ignored set, to be updated in the future
-	ASSERT_EQ(falco::app::ignored_sc_set().size(), 14);
-
-	// we don't expect to ignore any syscall in the default base set
-	ASSERT_EQ(falco::app::ignored_sc_set().intersect(libsinsp::events::sinsp_state_sc_set()).size(), 0);
-}
--- a/unit_tests/falco/app/actions/test_select_event_sources.cpp
+++ b/unit_tests/falco/app/actions/test_select_event_sources.cpp
@@ -1,105 +0,0 @@
-/*
-Copyright (C) 2023 The Falco Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless ASSERTd by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-#include <gtest/gtest.h>
-#include <falco/app/state.h>
-#include <falco/app/actions/actions.h>
-
-#define EXPECT_ACTION_OK(r)     { EXPECT_TRUE(r.success); EXPECT_TRUE(r.proceed); EXPECT_EQ(r.errstr, ""); }
-#define EXPECT_ACTION_FAIL(r)   { EXPECT_FALSE(r.success); EXPECT_FALSE(r.proceed); EXPECT_NE(r.errstr, ""); }
-
-TEST(ActionSelectEventSources, pre_post_conditions)
-{
-    auto action = falco::app::actions::select_event_sources;
-
-    // requires sources to be already loaded
-    {
-        falco::app::state s;
-        EXPECT_ACTION_FAIL(action(s));
-    }
-
-    // ignore source selection in capture mode
-    {
-        falco::app::state s;
-        s.options.trace_filename = "some_capture_file.scap";
-        EXPECT_TRUE(s.is_capture_mode());
-        EXPECT_ACTION_OK(action(s));
-    }
-
-    // enable all loaded sources by default, even with multiple calls
-    {
-        falco::app::state s;
-        s.loaded_sources = {"syscall", "some_source"};
-        EXPECT_ACTION_OK(action(s));
-        EXPECT_EQ(s.loaded_sources.size(), s.enabled_sources.size());
-        for (const auto& v : s.loaded_sources)
-        {
-            ASSERT_TRUE(s.enabled_sources.find(v) != s.enabled_sources.end());
-        }
-        s.loaded_sources.push_back("another_source");
-        EXPECT_ACTION_OK(action(s));
-        EXPECT_EQ(s.loaded_sources.size(), s.enabled_sources.size());
-        for (const auto& v : s.loaded_sources)
-        {
-            ASSERT_TRUE(s.enabled_sources.find(v) != s.enabled_sources.end());
-        }
-    }
-
-    // enable only selected sources
-    {
-        falco::app::state s;
-        s.loaded_sources = {"syscall", "some_source"};
-        s.options.enable_sources = {"syscall"};
-        EXPECT_ACTION_OK(action(s));
-        EXPECT_EQ(s.enabled_sources.size(), 1);
-        EXPECT_EQ(*s.enabled_sources.begin(), "syscall");
-    }
-
-    // enable all loaded sources expect the disabled ones
-    {
-        falco::app::state s;
-        s.loaded_sources = {"syscall", "some_source"};
-        s.options.disable_sources = {"syscall"};
-        EXPECT_ACTION_OK(action(s));
-        EXPECT_EQ(s.enabled_sources.size(), 1);
-        EXPECT_EQ(*s.enabled_sources.begin(), "some_source");
-    }
-
-    // enable unknown sources
-    {
-        falco::app::state s;
-        s.loaded_sources = {"syscall", "some_source"};
-        s.options.enable_sources = {"some_other_source"};
-        EXPECT_ACTION_FAIL(action(s));
-    }
-
-    // disable unknown sources
-    {
-        falco::app::state s;
-        s.loaded_sources = {"syscall", "some_source"};
-        s.options.disable_sources = {"some_other_source"};
-        EXPECT_ACTION_FAIL(action(s));
-    }
-
-    // mix enable and disable sources options
-    {
-        falco::app::state s;
-        s.loaded_sources = {"syscall", "some_source"};
-        s.options.disable_sources = {"syscall"};
-        s.options.enable_sources = {"syscall"};
-        EXPECT_ACTION_FAIL(action(s));
-    }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Federico Di Pierro	43e4d25848	chore(ci): properly checkout pull request HEAD instead of merge commit in gh actions. See https://github.com/actions/checkout#checkout-pull-request-head-commit-instead-of-merge-commit. Signed-off-by: Federico Di Pierro <nierro92@gmail.com>	2022-12-05 15:59:30 +01:00
Federico Di Pierro	67d592e83a	fix(cmake): properly fetch dev version by appending latest Falco tag, delta between master and tag, and hash. `describe` can no more be used as tags are now made on release branches. Signed-off-by: Federico Di Pierro <nierro92@gmail.com>	2022-12-05 15:55:17 +01:00