knapsack_pro 10.0.0 → 11.0.0

data/lib/knapsack_pro/config/env.rb

@@ -20,12 +20,6 @@ module KnapsackPro
           @ci_node_index ||= (env_for('KNAPSACK_PRO_CI_NODE_INDEX', :node_index) || 0).to_i
         end
 
-        def ci_node_build_id
-          env_name = 'KNAPSACK_PRO_CI_NODE_BUILD_ID'
-          env_for(env_name, :node_build_id) ||
-            raise("Missing environment variable #{env_name}. Read more at #{KnapsackPro::Urls::KNAPSACK_PRO_CI_NODE_BUILD_ID}")
-        end
-
         def ci_node_retry_count
           (env_for('KNAPSACK_PRO_CI_NODE_RETRY_COUNT', :node_retry_count) || 0).to_i
         end
@@ -95,12 +89,12 @@ module KnapsackPro
           ENV['KNAPSACK_PRO_REPOSITORY_ADAPTER']
         end
 
-        def regular_mode?
-          ENV['KNAPSACK_PRO_REGULAR_MODE_ENABLED'] == 'true'
+        def single_batch_mode?
+          ENV['KNAPSACK_PRO_SINGLE_BATCH_MODE_ENABLED'] == 'true'
         end
 
-        def queue_mode?
-          ENV['KNAPSACK_PRO_QUEUE_MODE_ENABLED'] == 'true'
+        def normal_mode?
+          ENV['KNAPSACK_PRO_NORMAL_MODE_ENABLED'] == 'true'
         end
 
         def queue_id
@@ -143,35 +137,8 @@ module KnapsackPro
           ENV.fetch('KNAPSACK_PRO_ENDPOINT', 'https://api.knapsackpro.com')
         end
 
-        def fixed_test_suite_split
-          ENV.fetch('KNAPSACK_PRO_FIXED_TEST_SUITE_SPLIT', true)
-        end
-
-        def fixed_test_suite_split?
-          fixed_test_suite_split.to_s == 'true'
-        end
-
-        def fixed_queue_split
-          @fixed_queue_split ||= begin
-            env_name = 'KNAPSACK_PRO_FIXED_QUEUE_SPLIT'
-            computed = env_for(env_name, :fixed_queue_split).to_s
-
-            if !ENV.key?(env_name)
-              KnapsackPro.logger.info("#{env_name} is not set. Using default value: #{computed}. Learn more at #{KnapsackPro::Urls::FIXED_QUEUE_SPLIT}")
-            end
-
-            computed
-          end
-        end
-
-        def fixed_queue_split_?
-          return @fixed_queue_split_ if defined?(@fixed_queue_split_)
-
-          @fixed_queue_split_ = env_for('KNAPSACK_PRO_FIXED_QUEUE_SPLIT', :fixed_queue_split).to_s == "true"
-        end
-
-        def fixed_queue_split?
-          fixed_queue_split.to_s == 'true'
+        def single_batch?
+          ENV.fetch('KNAPSACK_PRO_SINGLE_BATCH', 'false') == 'true'
         end
 
         def cucumber_queue_prefix
@@ -269,8 +236,11 @@ module KnapsackPro
         def test_queue_id
           knapsack_env_name = 'KNAPSACK_PRO_TEST_QUEUE_ID'
           knapsack_env_value = ENV[knapsack_env_name]
+          if knapsack_env_value == '' || knapsack_env_value&.match?(/[^a-z0-9\-_]+/i)
+            raise "Invalid test_queue_id `#{knapsack_env_value}`: Only ASCII letters, numbers, hyphens (-), and underscores (_) are allowed."
+          end
 
-          ci_env_value = detected_ci.new.test_queue_id
+          ci_env_value = detected_ci.new.test_queue_id&.gsub(/[^a-z0-9\-_]+/i, "-")
 
           if !knapsack_env_value.nil? && !ci_env_value.nil? && knapsack_env_value != ci_env_value.to_s
             warn("You have set the environment variable #{knapsack_env_name} to #{knapsack_env_value} which could be automatically determined from the CI environment as #{ci_env_value}.")
@@ -279,17 +249,12 @@ module KnapsackPro
           id = knapsack_env_value != nil ? knapsack_env_value : ci_env_value
           return id unless id.nil?
 
-          triplet = [ci_node_total, branch, commit_hash]
-          return triplet.join('-') if triplet.all?
+          triplet = [ci_node_total, KnapsackPro::Crypto::BranchEncryptor.call(branch), commit_hash]
+          return triplet.join('_').gsub(/[^a-z0-9\-_]+/i, "-") if triplet.all?
 
           raise("Missing test_queue_id. See: #{KnapsackPro::Urls::KNAPSACK_PRO_TEST_QUEUE_ID}")
         end
 
-        def node_uuid
-          env_name = 'KNAPSACK_PRO_NODE_UUID'
-          ENV[env_name] || raise("Missing environment variable #{env_name}. Please report this as a bug: #{KnapsackPro::Urls::SUPPORT}")
-        end
-
         private
 
         def required_env(env_name)

data/lib/knapsack_pro/crypto/branch_encryptor.rb

@@ -22,11 +22,10 @@ module KnapsackPro
       ]
 
       def self.call(branch)
-        if KnapsackPro::Config::Env.branch_encrypted?
-          new(branch).call
-        else
-          branch
-        end
+        return branch if branch.nil?
+        return branch unless KnapsackPro::Config::Env.branch_encrypted?
+
+        new(branch).call
       end
 
       def initialize(branch)

data/lib/knapsack_pro/extensions/rspec_extension.rb

@@ -77,7 +77,7 @@ module KnapsackPro
         # Based on:
         # https://github.com/rspec/rspec-core/blob/f8c8880dabd8f0544a6f91d8d4c857c1bd8df903/lib/rspec/core/runner.rb#L113
         #
-        # Ignore `configuration.fail_if_no_examples` in Queue Mode:
+        # Ignore `configuration.fail_if_no_examples`:
         #   * a late CI node, started after all tests were executed by other nodes, is expected to receive an empty batch
         #   * a batch could contain tests with no examples (e.g. commented out)
         #

data/lib/knapsack_pro/formatters/time_tracker.rb

@@ -35,10 +35,12 @@ module KnapsackPro
         paths =
           examples_by_file_path.flat_map do |file_path, examples|
             failed_id_paths = examples.filter { |example| example.execution_result.status.to_s == "failed" }.map(&:id)
-
+            next [] if failed_id_paths.none?
+            next file_path if KnapsackPro::Config::Env.test_files_encrypted?
             # Other nodes may have run some examples from this file, it's not safe to compact.
             next failed_id_paths if rspec_split_by_test_example?(file_path)
             next file_path if failed_id_paths.size == examples.size
+
             failed_id_paths
           end
 

data/lib/knapsack_pro/queue_allocator.rb

@@ -14,7 +14,7 @@ module KnapsackPro
 
       def queue_exists?
         raise "Connection failed. Please report this as a bug: #{KnapsackPro::Urls::SUPPORT}" if connection_failed?
-        return false if connection.api_code == KnapsackPro::Client::API::V1::Queues::CODE_ATTEMPT_CONNECT_TO_QUEUE_FAILED
+        return false if connection.api_code == KnapsackPro::Client::API::V2::Queues::CODE_ATTEMPT_CONNECT_TO_QUEUE_FAILED
 
         true
       end
@@ -24,11 +24,11 @@ module KnapsackPro
       end
 
       def test_files
-        if response.key?('test_files')
-          response.fetch('test_files')
-        else
-          response.fetch('paths').map { |path| { "path" => path, "time_execution" => nil } }
-        end
+        paths.map { |path| { "path" => path, "time_execution" => nil } }
+      end
+
+      def paths
+        response.fetch('paths')
       end
 
       def id
@@ -47,30 +47,31 @@ module KnapsackPro
       @repository_adapter = args.fetch(:repository_adapter)
       @fallback_mode = false
       @batch_index = -1
-      @batch_id = nil
+      @node_uuid = SecureRandom.uuid
+      @current_batch = nil
     end
 
-    def test_file_paths(can_initialize_queue, executed_test_files, batch_uuid: SecureRandom.uuid, time_tracker: nil)
+    def test_file_paths(can_initialize_queue, executed_test_files, time_tracker: nil)
       @batch_index += 1
       return [] if @fallback_mode
 
-      batch = pull_tests_from_queue(can_initialize_queue, batch_uuid, time_tracker: time_tracker)
+      batch = pull_tests_from_queue(can_initialize_queue, time_tracker: time_tracker)
 
       return switch_to_fallback_mode(executed_test_files: executed_test_files) if batch.connection_failed?
       return normalize_test_files(batch.test_files) if batch.queue_exists?
 
       test_files_result = test_suite.calculate_test_files
 
-      return try_initializing_queue(test_files_result.test_files, batch_uuid, time_tracker: time_tracker) if test_files_result.quick?
+      return try_initializing_queue(test_files_result.test_files.map { |test| test.fetch("path") }, time_tracker: time_tracker) if test_files_result.quick?
 
       # The tests to run were found slowly. By that time, the queue could have already been initialized by another CI node.
       # Attempt to pull tests from the queue to avoid the attempt to initialize the queue unnecessarily (queue initialization is an expensive request with a big test files payload).
-      batch = pull_tests_from_queue(can_initialize_queue, batch_uuid, time_tracker: time_tracker)
+      batch = pull_tests_from_queue(can_initialize_queue, time_tracker: time_tracker)
 
       return switch_to_fallback_mode(executed_test_files: executed_test_files) if batch.connection_failed?
       return normalize_test_files(batch.test_files) if batch.queue_exists?
 
-      try_initializing_queue(test_files_result.test_files, batch_uuid, time_tracker: time_tracker)
+      try_initializing_queue(test_files_result.test_files.map { |test| test.fetch("path") }, time_tracker: time_tracker)
     end
 
     private
@@ -86,102 +87,51 @@ module KnapsackPro
       KnapsackPro::TestFilePresenter.paths(decrypted_test_files)
     end
 
-    def build_action_v1(can_initialize_queue:, attempt_connect_to_queue:, batch_uuid:, test_files: nil)
-      if can_initialize_queue && !attempt_connect_to_queue
-        raise 'Test files are required when initializing a new queue.' if test_files.nil?
-        test_files = KnapsackPro::Crypto::Encryptor.call(test_files)
-      end
-
-      KnapsackPro::Client::API::V1::Queues.queue(
-        can_initialize_queue: can_initialize_queue,
-        attempt_connect_to_queue: attempt_connect_to_queue,
-        commit_hash: repository_adapter.commit_hash,
-        branch: encrypted_branch,
-        node_total: ci_node_total,
-        node_index: ci_node_index,
-        test_files: test_files,
-        batch_uuid: batch_uuid
-      )
-    end
-
-    def build_action_v2(can_initialize_queue:, attempt_connect_to_queue:, time_tracker:, paths: nil)
+    # time_tracker is nil for non-RSpec queue runners
+    def build_action(can_initialize_queue:, attempt_connect_to_queue:, time_tracker:, paths: nil)
       if can_initialize_queue && !attempt_connect_to_queue
         raise 'Test files are required when initializing a new queue.' if paths.nil?
         paths = KnapsackPro::Crypto::Encryptor.paths(paths)
       end
 
+      failed_paths =
+        if time_tracker
+          KnapsackPro::Crypto::Encryptor.paths(time_tracker.current_batch_failed_paths)
+        elsif @batch_index.positive?
+          KnapsackPro::Crypto::Encryptor.paths(@current_batch.paths)
+        end
+
       KnapsackPro::Client::API::V2::Queues.queue(
-        can_initialize_queue: can_initialize_queue,
         attempt_connect_to_queue: attempt_connect_to_queue,
-        commit_hash: repository_adapter.commit_hash,
+        batch_id: @current_batch&.id,
+        batch_index: @batch_index,
         branch: encrypted_branch,
-        node_total: ci_node_total,
+        can_initialize_queue: can_initialize_queue,
+        commit_hash: repository_adapter.commit_hash,
+        failed_paths: failed_paths,
         node_index: ci_node_index,
-        paths: paths,
-        failed_paths: time_tracker.current_batch_failed_paths,
-        batch_index: @batch_index,
-        batch_id: @batch_id
+        node_total: ci_node_total,
+        node_uuid: @node_uuid,
+        paths: paths
       )
     end
 
-    def pull_tests_from_queue(can_initialize_queue, batch_uuid, time_tracker: nil)
-      if time_tracker.nil?
-        pull_tests_from_queue_v1(can_initialize_queue, batch_uuid)
-      else
-        pull_tests_from_queue_v2(can_initialize_queue, time_tracker)
-      end
-    end
-
-    def pull_tests_from_queue_v1(can_initialize_queue, batch_uuid)
-      action = build_action_v1(can_initialize_queue: can_initialize_queue, attempt_connect_to_queue: can_initialize_queue, batch_uuid: batch_uuid)
-      connection = KnapsackPro::Client::Connection.new(action)
-      response = connection.call
-      Batch.new(connection, response)
-    end
-
-    def pull_tests_from_queue_v2(can_initialize_queue, time_tracker)
-      action = build_action_v2(can_initialize_queue: can_initialize_queue, attempt_connect_to_queue: can_initialize_queue, time_tracker: time_tracker)
-      connection = KnapsackPro::Client::Connection.new(action)
-      response = connection.call
-      Batch.new(connection, response).tap do |batch|
-        @batch_id = batch.id unless batch.connection_failed?
-      end
-    end
-
-    def initialize_queue_v1(tests_to_run, batch_uuid)
-      action = build_action_v1(can_initialize_queue: true, attempt_connect_to_queue: false, batch_uuid: batch_uuid, test_files: tests_to_run)
+    def pull_tests_from_queue(can_initialize_queue, time_tracker: nil)
+      action = build_action(can_initialize_queue: can_initialize_queue, attempt_connect_to_queue: can_initialize_queue, time_tracker: time_tracker)
       connection = KnapsackPro::Client::Connection.new(action)
       response = connection.call
-      Batch.new(connection, response)
+      @current_batch = Batch.new(connection, response)
     end
 
-    def initialize_queue_v2(paths, time_tracker)
-      action = build_action_v2(can_initialize_queue: true, attempt_connect_to_queue: false, paths: paths, time_tracker: time_tracker)
+    def initialize_queue(paths, time_tracker: nil)
+      action = build_action(can_initialize_queue: true, attempt_connect_to_queue: false, paths: paths, time_tracker: time_tracker)
       connection = KnapsackPro::Client::Connection.new(action)
       response = connection.call
-      Batch.new(connection, response).tap do |batch|
-        @batch_id = batch.id unless batch.connection_failed?
-      end
-    end
-
-    def try_initializing_queue(tests, batch_uuid, time_tracker: nil)
-      if time_tracker.nil?
-        try_initializing_queue_v1(tests, batch_uuid)
-      else
-        paths = tests.map { |test| test.fetch("path") }
-        try_initializing_queue_v2(paths, time_tracker)
-      end
+      @current_batch = Batch.new(connection, response)
     end
 
-    def try_initializing_queue_v1(tests, batch_uuid)
-      result = initialize_queue_v1(tests, batch_uuid)
-      return switch_to_fallback_mode(executed_test_files: []) if result.connection_failed?
-
-      normalize_test_files(result.test_files)
-    end
-
-    def try_initializing_queue_v2(paths, time_tracker)
-      result = initialize_queue_v2(paths, time_tracker)
+    def try_initializing_queue(paths, time_tracker: nil)
+      result = initialize_queue(paths, time_tracker: time_tracker)
       return switch_to_fallback_mode(executed_test_files: []) if result.connection_failed?
 
       normalize_test_files(result.test_files)
@@ -191,14 +141,11 @@ module KnapsackPro
       @fallback_mode = true
 
       if !KnapsackPro::Config::Env.fallback_mode_enabled?
-        message = "Fallback Mode was disabled with KNAPSACK_PRO_FALLBACK_MODE_ENABLED=false. Please restart this CI node to retry tests. Most likely Fallback Mode was disabled due to #{KnapsackPro::Urls::QUEUE_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_FALSE}"
+        message = "Fallback Mode was disabled with KNAPSACK_PRO_FALLBACK_MODE_ENABLED=false. Please restart this CI node to retry tests. Most likely Fallback Mode was disabled due to #{KnapsackPro::Urls::NORMAL_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_FALSE}"
         KnapsackPro.logger.error(message)
         raise FallbackModeError.new(message)
       elsif KnapsackPro::Config::Env.ci_node_retry_count > 0
-        message = "knapsack_pro gem could not connect to Knapsack Pro API and the Fallback Mode cannot be used this time. Running tests in Fallback Mode are not allowed for retried parallel CI node to avoid running the wrong set of tests. Please manually retry this parallel job on your CI server then knapsack_pro gem will try to connect to Knapsack Pro API again and will run a correct set of tests for this CI node. Learn more #{KnapsackPro::Urls::QUEUE_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_TRUE_AND_POSITIVE_RETRY_COUNT}"
-        unless KnapsackPro::Config::Env.fixed_queue_split?
-          message += " Please ensure you have set KNAPSACK_PRO_FIXED_QUEUE_SPLIT=true to allow Knapsack Pro API remember the recorded CI node tests so when you retry failed tests on the CI node then the same set of tests will be executed. See more #{KnapsackPro::Urls::FIXED_QUEUE_SPLIT}"
-        end
+        message = "knapsack_pro gem could not connect to Knapsack Pro API and the Fallback Mode cannot be used this time. Running tests in Fallback Mode are not allowed for retried parallel CI node to avoid running the wrong set of tests. Please manually retry this parallel job on your CI server then knapsack_pro gem will try to connect to Knapsack Pro API again and will run a correct set of tests for this CI node. Learn more #{KnapsackPro::Urls::NORMAL_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_TRUE_AND_POSITIVE_RETRY_COUNT}"
         KnapsackPro.logger.error(message)
         raise FallbackModeError.new(message)
       else

data/lib/knapsack_pro/regular_allocator.rb

@@ -12,7 +12,7 @@ module KnapsackPro
 
       def exists?
         raise "Connection failed. Please report this as a bug: #{KnapsackPro::Urls::SUPPORT}" if connection_failed?
-        return false if connection.api_code == KnapsackPro::Client::API::V1::BuildDistributions::TEST_SUITE_SPLIT_CACHE_MISS_CODE
+        return false if connection.api_code == KnapsackPro::Client::API::V2::Queues::CODE_ATTEMPT_CONNECT_TO_QUEUE_FAILED
 
         true
       end
@@ -22,7 +22,11 @@ module KnapsackPro
       end
 
       def test_files
-        response.fetch('test_files')
+        response.fetch('paths').map { |path| { "path" => path, "time_execution" => nil } }
+      end
+
+      def id
+        response.fetch('batch_id', nil)
       end
 
       private
@@ -74,33 +78,53 @@ module KnapsackPro
     end
 
     def build_action(cache_read_attempt:, test_files: nil)
-      unless cache_read_attempt
+      if cache_read_attempt # connect
+        KnapsackPro::Client::API::V2::Queues.queue(
+          attempt_connect_to_queue: true,
+          batch_index: 0,
+          branch: encrypted_branch,
+          can_initialize_queue: true,
+          commit_hash: repository_adapter.commit_hash,
+          node_index: ci_node_index,
+          node_total: ci_node_total,
+          node_uuid: ENV.fetch('KNAPSACK_PRO_NODE_UUID'),
+          single_batch: true
+        )
+      else # initialize
         raise 'Test files are required when initializing a new test suite split.' if test_files.nil?
-        test_files = KnapsackPro::Crypto::Encryptor.call(test_files)
+        paths = test_files.map { |test_file| test_file.fetch("path") }
+
+        KnapsackPro::Client::API::V2::Queues.queue(
+          attempt_connect_to_queue: false,
+          batch_index: 0,
+          branch: encrypted_branch,
+          can_initialize_queue: true,
+          commit_hash: repository_adapter.commit_hash,
+          node_index: ci_node_index,
+          node_total: ci_node_total,
+          node_uuid: ENV.fetch('KNAPSACK_PRO_NODE_UUID'),
+          paths: KnapsackPro::Crypto::Encryptor.paths(paths),
+          single_batch: true
+        )
       end
-
-      KnapsackPro::Client::API::V1::BuildDistributions.subset(
-        cache_read_attempt: cache_read_attempt,
-        commit_hash: repository_adapter.commit_hash,
-        branch: encrypted_branch,
-        node_total: ci_node_total,
-        node_index: ci_node_index,
-        test_files: test_files,
-      )
     end
 
     def pull_tests
       action = build_action(cache_read_attempt: true)
       connection = KnapsackPro::Client::Connection.new(action)
       response = connection.call
-      Split.new(connection, response)
+      Split.new(connection, response).tap do |batch|
+        ENV['KNAPSACK_PRO_BATCH_ID'] = batch.id.to_s unless batch.connection_failed?
+      end
     end
 
     def initialize_test_suite_split(tests_to_run)
       action = build_action(cache_read_attempt: false, test_files: tests_to_run)
       connection = KnapsackPro::Client::Connection.new(action)
       response = connection.call
-      Split.new(connection, response)
+      Split.new(connection, response).tap do |batch|
+        ENV['KNAPSACK_PRO_BATCH_ID'] = batch.id.to_s unless batch.connection_failed?
+      end
     end
 
     def try_initializing_test_suite_split(tests)
@@ -113,15 +137,12 @@ module KnapsackPro
 
     def switch_to_fallback_mode
       if !KnapsackPro::Config::Env.fallback_mode_enabled?
-        message = "Fallback Mode was disabled with KNAPSACK_PRO_FALLBACK_MODE_ENABLED=false. Please restart this CI node to retry tests. Most likely Fallback Mode was disabled due to #{KnapsackPro::Urls::REGULAR_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_FALSE}"
+        message = "Fallback Mode was disabled with KNAPSACK_PRO_FALLBACK_MODE_ENABLED=false. Please restart this CI node to retry tests. Most likely Fallback Mode was disabled due to #{KnapsackPro::Urls::SINGLE_BATCH_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_FALSE}"
         KnapsackPro.logger.error(message)
         exit_code = KnapsackPro::Config::Env.fallback_mode_error_exit_code
         Kernel.exit(exit_code)
       elsif KnapsackPro::Config::Env.ci_node_retry_count > 0
-        message = "knapsack_pro gem could not connect to Knapsack Pro API and the Fallback Mode cannot be used this time. Running tests in Fallback Mode are not allowed for retried parallel CI node to avoid running the wrong set of tests. Please manually retry this parallel job on your CI server then knapsack_pro gem will try to connect to Knapsack Pro API again and will run a correct set of tests for this CI node. Learn more #{KnapsackPro::Urls::REGULAR_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_TRUE_AND_POSITIVE_RETRY_COUNT}"
-        unless KnapsackPro::Config::Env.fixed_test_suite_split?
-          message += " Please ensure you have set KNAPSACK_PRO_FIXED_TEST_SUITE_SPLIT=true to allow Knapsack Pro API remember the recorded CI node tests so when you retry failed tests on the CI node then the same set of tests will be executed. See more #{KnapsackPro::Urls::FIXED_TEST_SUITE_SPLIT}"
-        end
+        message = "knapsack_pro gem could not connect to Knapsack Pro API and the Fallback Mode cannot be used this time. Running tests in Fallback Mode are not allowed for retried parallel CI node to avoid running the wrong set of tests. Please manually retry this parallel job on your CI server then knapsack_pro gem will try to connect to Knapsack Pro API again and will run a correct set of tests for this CI node. Learn more #{KnapsackPro::Urls::SINGLE_BATCH_MODE__CONNECTION_ERROR_WITH_FALLBACK_ENABLED_TRUE_AND_POSITIVE_RETRY_COUNT}"
         KnapsackPro.logger.error(message)
         exit_code = KnapsackPro::Config::Env.fallback_mode_error_exit_code
         Kernel.exit(exit_code)

data/lib/knapsack_pro/report.rb

@@ -2,17 +2,17 @@
 
 module KnapsackPro
   class Report
-    def self.save(tests = nil)
-      if tests.nil?
-        tests = KnapsackPro.tracker.to_a
+    def self.save(test_files = nil)
+      if test_files.nil?
+        test_files = KnapsackPro.tracker.to_a
       end
 
-      if tests.empty?
-        KnapsackPro.logger.warn("No test files were executed on this CI node.")
-        KnapsackPro.logger.debug("When you use knapsack_pro Regular Mode, the reason for no tests executing might be a very narrow tests list. Most likely, you run only tests with a specified tag, and there were fewer test files with the tag than parallel CI nodes.")
+      if test_files.empty?
+        KnapsackPro.logger.info("No tests were executed because the test queue is empty.")
       end
 
-      create_build_subset(tests)
+      acknowledge_single_batch(test_files)
+      create_build_subset(test_files)
     end
 
     def self.save_subset_queue_to_file
@@ -59,6 +59,35 @@ module KnapsackPro
       create_build_subset(test_files)
     end
 
+    # TODO: Add support for Retry-only-Failures
+    def self.acknowledge_single_batch(test_files)
+      repository_adapter = KnapsackPro::RepositoryAdapterInitiator.call
+      paths = KnapsackPro::Utils.unsymbolize(test_files).map { |test_file| test_file.fetch('path') }
+      failed_paths = KnapsackPro::Crypto::Encryptor.paths(paths)
+      action = KnapsackPro::Client::API::V2::Queues.queue(
+        attempt_connect_to_queue: false,
+        batch_id: ENV['KNAPSACK_PRO_BATCH_ID'], # nil in Fallback Mode
+        batch_index: 1,
+        branch: KnapsackPro::Crypto::BranchEncryptor.call(repository_adapter.branch),
+        can_initialize_queue: false,
+        commit_hash: repository_adapter.commit_hash,
+        failed_paths: failed_paths,
+        node_total: KnapsackPro::Config::Env.ci_node_total,
+        node_index: KnapsackPro::Config::Env.ci_node_index,
+        node_uuid: ENV.fetch('KNAPSACK_PRO_NODE_UUID'),
+        single_batch: true
+      )
+
+      connection = KnapsackPro::Client::Connection.new(action)
+      response = connection.call
+      if connection.success?
+        raise ArgumentError.new(response) if connection.errors?
+        KnapsackPro.logger.debug('Acknowledged single batch.')
+      else
+        KnapsackPro.logger.warn('Single batch was not acknowledged due to connection problems.')
+      end
+    end
+
     def self.create_build_subset(test_files)
       repository_adapter = KnapsackPro::RepositoryAdapterInitiator.call
       test_files = KnapsackPro::Utils.unsymbolize(test_files)
@@ -77,7 +106,7 @@ module KnapsackPro
         raise ArgumentError.new(response) if connection.errors?
         KnapsackPro.logger.debug('Saved time execution report on Knapsack Pro API server.')
       else
-        KnapsackPro.logger.warn('Time execution report was not saved on Knapsack Pro API server due to connection problem.')
+        KnapsackPro.logger.warn('Time execution report was not saved on Knapsack Pro API server due to connection problems.')
       end
     end
 

data/lib/knapsack_pro/repository_adapters/git_adapter.rb

@@ -4,11 +4,11 @@ module KnapsackPro
   module RepositoryAdapters
     class GitAdapter < BaseAdapter
       def commit_hash
-        `git -C "#{working_dir}" rev-parse HEAD`.strip
+        ENV['KNAPSACK_PRO_COMMIT_HASH'] || git_commit_hash
       end
 
       def branch
-        `git -C "#{working_dir}" rev-parse --abbrev-ref HEAD`.strip
+        ENV['KNAPSACK_PRO_BRANCH'] || git_branch
       end
 
       def branches
@@ -42,6 +42,14 @@ module KnapsackPro
 
       private
 
+      def git_commit_hash
+        `git -C "#{working_dir}" rev-parse HEAD`.strip
+      end
+
+      def git_branch
+        `git -C "#{working_dir}" rev-parse --abbrev-ref HEAD`.strip
+      end
+
       def git_commit_authors
         git_unshallow if KnapsackPro::Config::Env.ci? && shallow_repository?
         `git log --since "one month ago" 2>/dev/null | git shortlog --summary --email 2>/dev/null`

data/lib/knapsack_pro/runners/cucumber_runner.rb

@@ -5,7 +5,8 @@ module KnapsackPro
     class CucumberRunner < BaseRunner
       def self.run(args)
         ENV['KNAPSACK_PRO_TEST_SUITE_TOKEN'] = KnapsackPro::Config::Env.test_suite_token_cucumber
-        ENV['KNAPSACK_PRO_REGULAR_MODE_ENABLED'] = 'true'
+        ENV['KNAPSACK_PRO_SINGLE_BATCH_MODE_ENABLED'] = 'true'
+        ENV['KNAPSACK_PRO_NODE_UUID'] = SecureRandom.uuid
 
         adapter_class = KnapsackPro::Adapters::CucumberAdapter
         KnapsackPro::Config::Env.set_test_runner_adapter(adapter_class)

data/lib/knapsack_pro/runners/minitest_runner.rb

@@ -5,7 +5,8 @@ module KnapsackPro
     class MinitestRunner < BaseRunner
       def self.run(args)
         ENV['KNAPSACK_PRO_TEST_SUITE_TOKEN'] = KnapsackPro::Config::Env.test_suite_token_minitest
-        ENV['KNAPSACK_PRO_REGULAR_MODE_ENABLED'] = 'true'
+        ENV['KNAPSACK_PRO_SINGLE_BATCH_MODE_ENABLED'] = 'true'
+        ENV['KNAPSACK_PRO_NODE_UUID'] = SecureRandom.uuid
 
         adapter_class = KnapsackPro::Adapters::MinitestAdapter
         KnapsackPro::Config::Env.set_test_runner_adapter(adapter_class)

data/lib/knapsack_pro/runners/queue/base_runner.rb

@@ -5,7 +5,6 @@ module KnapsackPro
     module Queue
       class BaseRunner
         TerminationError = Class.new(StandardError)
-        TERMINATION_SIGNALS = %w(HUP INT TERM ABRT QUIT USR1 USR2)
 
         @@terminate_process = false
 
@@ -56,17 +55,27 @@ module KnapsackPro
         end
 
         def trap_signals
-          TERMINATION_SIGNALS.each do |signal|
-            Signal.trap(signal) {
-              puts "#{signal} signal has been received. Terminating Knapsack Pro..."
+          Signal.trap("TERM") {
+            puts "SIGTERM received: Terminating Knapsack Pro..."
+            @@terminate_process = true
+            post_trap_signals(debug: true)
+            log_threads
+          }
+
+          Signal.trap("INT") {
+            if @@terminate_process
+              puts "SIGINT received: Terminated Knapsack Pro."
+              $stdout.flush
+              exit!(1)
+            else
+              puts "SIGINT received: Terminating Knapsack Pro... Interrupt again to force quit."
               @@terminate_process = true
               post_trap_signals
-              log_threads
-            }
-          end
+            end
+          }
         end
 
-        def post_trap_signals
+        def post_trap_signals(debug: false)
         end
 
         def log_threads

data/lib/knapsack_pro/runners/queue/cucumber_runner.rb

@@ -8,7 +8,7 @@ module KnapsackPro
           require 'cucumber/rake/task'
 
           ENV['KNAPSACK_PRO_TEST_SUITE_TOKEN'] = KnapsackPro::Config::Env.test_suite_token_cucumber
-          ENV['KNAPSACK_PRO_QUEUE_MODE_ENABLED'] = 'true'
+          ENV['KNAPSACK_PRO_NORMAL_MODE_ENABLED'] = 'true'
           ENV['KNAPSACK_PRO_QUEUE_ID'] = KnapsackPro::Config::EnvGenerator.set_queue_id
 
           adapter_class = KnapsackPro::Adapters::CucumberAdapter

data/lib/knapsack_pro/runners/queue/minitest_runner.rb

@@ -12,7 +12,7 @@ module KnapsackPro
           ::Minitest.class_variable_set('@@installed_at_exit', true)
 
           ENV['KNAPSACK_PRO_TEST_SUITE_TOKEN'] = KnapsackPro::Config::Env.test_suite_token_minitest
-          ENV['KNAPSACK_PRO_QUEUE_MODE_ENABLED'] = 'true'
+          ENV['KNAPSACK_PRO_NORMAL_MODE_ENABLED'] = 'true'
           ENV['KNAPSACK_PRO_QUEUE_ID'] = KnapsackPro::Config::EnvGenerator.set_queue_id
 
           adapter_class = KnapsackPro::Adapters::MinitestAdapter