pact_broker 2.118.0 → 2.120.0

data/lib/pact_broker/db/clean.rb

@@ -2,6 +2,7 @@ require "sequel"
 require "pact_broker/project_root"
 require "pact_broker/logging"
 require "pact_broker/db/clean/selector"
+require "pact_broker/db/clean/branch_selector"
 
 module PactBroker
   module DB
@@ -130,6 +131,9 @@ module PactBroker
         delete_orphan_tags
         delete_orphan_versions
 
+        deleted_counts[:stale_branches] = delete_stale_branches
+        kept_counts[:stale_branches] = db[:branches].count
+
         { kept: kept_counts, deleted: deleted_counts }
       end
 
@@ -180,6 +184,47 @@ module PactBroker
         db[:versions].where(id: referenced_version_ids).invert.delete
       end
 
+      def delete_stale_branches
+        return 0 unless keep_branches && !keep_branches.empty?
+
+        db[:branches].where(id: stale_branch_ids_to_delete.from_self.select(:id)).delete
+      end
+
+      def stale_branch_ids_to_delete
+        db[:branches]
+          .select(Sequel[:branches][:id])
+          .left_outer_join(stale_branch_ids_to_keep, { Sequel[:branches][:id] => Sequel[:keep_branches][:id] }, table_alias: :keep_branches)
+          .where(Sequel[:keep_branches][:id] => nil)
+      end
+
+      def stale_branch_ids_to_keep
+        queries = [main_branch_ids_to_keep]
+
+        keep_branches.each do | selector |
+          if selector.max_age
+            cutoff = Date.today - selector.max_age
+            queries << db[:branches].where { updated_at >= cutoff }.select(:id)
+          end
+          if selector.branch
+            queries << db[:branches].where(name: Array(selector.branch)).select(:id)
+          end
+        end
+
+        queries.reduce(:union)
+      end
+
+      def main_branch_ids_to_keep
+        db[:branches]
+          .join(:pacticipants, id: Sequel[:branches][:pacticipant_id])
+          .exclude(Sequel[:pacticipants][:main_branch] => nil)
+          .where(Sequel[:branches][:name] => Sequel[:pacticipants][:main_branch])
+          .select(Sequel[:branches][:id])
+      end
+
+      def keep_branches
+        @keep_branches ||= options[:keep_branches]&.collect { | selector_hash | BranchSelector.from_hash(selector_hash.to_hash) }
+      end
+
       def delete_overwritten_verifications
         verification_ids = db[:verifications].select(:id).where(id: db[:latest_verification_id_for_pact_version_and_provider_version].select(:verification_id)).invert
         deleted_counts = { verification_results: verification_ids.count }

data/lib/pact_broker/db/clean_incremental.rb

@@ -2,6 +2,7 @@ require "pact_broker/logging"
 require "pact_broker/matrix/unresolved_selector"
 require "pact_broker/date_helper"
 require "pact_broker/db/clean/selector"
+require "pact_broker/db/clean/branch_selector"
 
 module PactBroker
   module DB
@@ -14,7 +15,10 @@ module PactBroker
         PactBroker::DB::Clean::Selector.new(released: true),
         PactBroker::DB::Clean::Selector.new(max_age: 90)
       ]
-      TABLES = [:versions, :pact_publications, :pact_versions, :verifications, :triggered_webhooks, :webhook_executions]
+      DEFAULT_KEEP_BRANCH_SELECTORS = [
+        PactBroker::DB::Clean::BranchSelector.new(max_age: 90)
+      ]
+      TABLES = [:versions, :pact_publications, :pact_versions, :verifications, :triggered_webhooks, :webhook_executions, :branches]
 
       def self.call database_connection, options = {}
         new(database_connection, options).call
@@ -44,6 +48,7 @@ module PactBroker
           before_counts = current_counts
           PactBroker::Domain::Version.where(id: versions_to_delete.from_self.select_map(:id)).delete
           delete_orphan_pact_versions
+          delete_stale_branches
           after_counts = current_counts
 
           TABLES.each_with_object({}) do | table_name, comparison_counts |
@@ -68,10 +73,22 @@ module PactBroker
                   end
       end
 
+      def keep_branches
+        @keep_branches ||= if options.key?(:keep_branches)
+                             options[:keep_branches]&.collect { | selector_hash | PactBroker::DB::Clean::BranchSelector.from_hash(selector_hash.to_hash) }
+                           else
+                             DEFAULT_KEEP_BRANCH_SELECTORS
+                           end
+      end
+
       def limit
         options[:limit] || 1000
       end
 
+      def branch_limit
+        options[:branch_limit] || limit
+      end
+
       def versions_to_delete(columns = [:id])
         fully_qualified_columns = columns.collect { |col| Sequel[:versions][col] }
         PactBroker::Domain::Version
@@ -96,6 +113,47 @@ module PactBroker
         options[:dry_run]
       end
 
+      def delete_stale_branches
+        return unless keep_branches && !keep_branches.empty?
+
+        # A direct subquery here fails in MySQL, so wrap the dataset in a
+        # derived table with `from_self` before selecting the ids for deletion.
+        PactBroker::Versions::Branch.where(id: stale_branch_ids_to_delete.from_self.select(:id)).delete
+      end
+
+      def stale_branch_ids_to_delete
+        PactBroker::Versions::Branch
+          .select(Sequel[:branches][:id])
+          .left_outer_join(stale_branch_ids_to_keep, { Sequel[:branches][:id] => Sequel[:keep_branches][:id] }, table_alias: :keep_branches)
+          .where(Sequel[:keep_branches][:id] => nil)
+          .limit(branch_limit)
+      end
+
+      def stale_branch_ids_to_keep
+        # Always keep main branches for each pacticipant
+        queries = [main_branch_ids_to_keep]
+
+        keep_branches.each do | selector |
+          if selector.max_age
+            cutoff = Date.today - selector.max_age
+            queries << PactBroker::Versions::Branch.where { updated_at >= cutoff }.select(Sequel[:branches][:id])
+          end
+          if selector.branch
+            queries << PactBroker::Versions::Branch.where(name: Array(selector.branch)).select(Sequel[:branches][:id])
+          end
+        end
+
+        queries.reduce(&:union)
+      end
+
+      def main_branch_ids_to_keep
+        PactBroker::Versions::Branch
+          .join(:pacticipants, id: Sequel[:branches][:pacticipant_id])
+          .exclude(Sequel[:pacticipants][:main_branch] => nil)
+          .where(Sequel[:branches][:name] => Sequel[:pacticipants][:main_branch])
+          .select(Sequel[:branches][:id])
+      end
+
       def delete_orphan_pact_versions
         db[:pact_versions].where(id: orphan_pact_versions).delete
       rescue Sequel::DatabaseError => e
@@ -142,19 +200,29 @@ module PactBroker
           }
         end
 
+        {
+          "counts" => dry_run_counts(kept_per_selector),
+          "versionSummary" => pacticipant_results
+        }
+      end
+
+      def dry_run_counts(kept_per_selector)
         total_versions_count = PactBroker::Domain::Version.count
         versions_to_keep_count = version_ids_to_keep.count
         versions_to_delete_count = versions_to_delete.count
 
+        total_branches_count = PactBroker::Versions::Branch.count
+        branches_to_delete_count = keep_branches && !keep_branches.empty? ? stale_branch_ids_to_delete.count : 0
+
         {
-          "counts" => {
-            "totalVersions" => total_versions_count,
-            "versionsToDelete" => versions_to_delete_count,
-            "versionsNotToKeep" => total_versions_count - versions_to_keep_count,
-            "versionsToKeep" => versions_to_keep_count,
-            "versionsToKeepBySelector" => kept_per_selector,
-          },
-          "versionSummary" => pacticipant_results
+          "totalVersions" => total_versions_count,
+          "versionsToDelete" => versions_to_delete_count,
+          "versionsNotToKeep" => total_versions_count - versions_to_keep_count,
+          "versionsToKeep" => versions_to_keep_count,
+          "versionsToKeepBySelector" => kept_per_selector,
+          "totalBranches" => total_branches_count,
+          "branchesToDelete" => branches_to_delete_count,
+          "branchesToKeep" => total_branches_count - branches_to_delete_count
         }
       end
 

data/lib/pact_broker/deployments/deployed_version_service.rb

@@ -68,6 +68,7 @@ module PactBroker
 
       def self.find_all_deployed_versions_for_pacticipant(pacticipant)
         scope_for(DeployedVersion)
+          .currently_deployed
           .where(pacticipant_id: pacticipant.id)
           .eager(:environment)
           .all

data/lib/pact_broker/deployments/released_version_service.rb

@@ -46,6 +46,20 @@ module PactBroker
           .single_record
       end
 
+      def self.find_released_versions_for_version(version)
+        scope_for(ReleasedVersion)
+          .where(version_id: version.id)
+          .eager(:environment)
+          .all
+      end
+
+      def self.find_released_versions_for_versions(versions_array)
+        scope_for(ReleasedVersion)
+          .where(version_id: versions_array.map(&:id))
+          .eager(:environment)
+          .to_hash_groups(:version_id)
+      end
+
       def self.record_version_support_ended(released_version)
         released_version.record_support_ended
       end

data/lib/pact_broker/domain/pacticipant.rb

@@ -55,11 +55,22 @@ module PactBroker
         PactBroker::Pacts::PactPublication.where(provider: self).delete
         PactBroker::Domain::Verification.where(consumer: self).or(provider: self).delete
         PactBroker::Domain::Version.where(pacticipant: self).delete
-        PactBroker::Pacts::PactVersion.where(consumer: self).or(provider: self).delete
+        delete_pact_versions_in_batches
         PactBroker::Domain::Label.where(pacticipant: self).destroy
         super
       end
 
+      BATCH_DELETE_SIZE = 500
+      def delete_pact_versions_in_batches
+        dataset = PactBroker::Pacts::PactVersion.where(consumer: self).or(provider: self).order(:id)
+        loop do
+          deleted = PactBroker::Pacts::PactVersion
+            .where(id: dataset.limit(BATCH_DELETE_SIZE).select(:id))
+            .delete
+          break if deleted.zero?
+        end
+      end
+
       def before_save
         super
         self.display_name = generate_display_name(name) if display_name.blank?

data/lib/pact_broker/logging.rb

@@ -52,6 +52,16 @@ module PactBroker
       end
     end
 
+    def measure_debug(message, payload: {})
+      if logger.respond_to?(:measure_debug)
+        logger.measure_debug(message, payload: payload) do
+          yield
+        end
+      else
+        yield
+      end
+    end
+
     def log_error e, description = nil
       if logger.instance_of?(SemanticLogger::Logger)
         if description

data/lib/pact_broker/matrix/parse_can_i_deploy_query.rb

@@ -26,6 +26,11 @@ module PactBroker
 
         if params[:environment].is_a?(String)
           options[:environment_name] = params[:environment]
+          # Multiple versions of an integrated application can be simultaneously released to an
+          # environment (record-release), or deployed to it on different targets (record-deployment).
+          # "cvp" collapses these down to the latest provider version, hiding incompatible versions
+          # that are still live. "cvpv" evaluates every co-resident version independently. See issue #903.
+          options[:latestby] = "cvpv"
         end
 
         if params[:ignore].is_a?(Array)

data/lib/pact_broker/pacticipants/repository.rb

@@ -41,7 +41,7 @@ module PactBroker
         return [] if query.empty?
 
         query = query.select_all_qualified
-        query = query.filter(:name, options[:query_string]) if options[:query_string]
+        query = query.filter(Sequel[:pacticipants][:name], options[:query_string]) if options[:query_string]
         query = query.label(options[:label_name]) if options[:label_name]
         query.order_ignore_case(Sequel[:pacticipants][:name]).eager(*eager_load_associations).all_with_pagination_options(pagination_options)
       end

data/lib/pact_broker/pacts/pact_publication_dataset_module.rb

@@ -287,9 +287,13 @@ module PactBroker
       # NEW LOGIC
       # @return [Sequel::Dataset<PactBroker::Pacts::PactPublication>]
       def for_all_tag_heads
+        # Optimization: Only aggregate tags for consumers that have pacts for this provider.
+        relevant_consumer_ids = self.select(:consumer_id).distinct
+
         head_tags = PactBroker::Domain::Tag
                       .select_group(:pacticipant_id, :name)
-                      .select_append{ max(version_order).as(:latest_version_order) }
+                      .select_append{ max(:version_order).as(:latest_version_order) }
+                      .where(pacticipant_id: relevant_consumer_ids)
 
         head_tags_join = {
           Sequel[:pact_publications][:consumer_id] => Sequel[:head_tags][:pacticipant_id],

data/lib/pact_broker/pacts/pact_publication_wip_dataset_module.rb

@@ -19,13 +19,19 @@ module PactBroker
           end
 
           def join_branch_versions_excluding_branch(provider_id, branch_name)
+            # Only check branches that have been active in the last N days
+            # to avoid old stale branches causing cartesian explosion.
+            # Filter by verification execution_date rather than version created_at
+            # to avoid incorrectly excluding old versions with recent verifications.
+            recent_branch_cutoff = DateTime.now - PactBroker.configuration.verified_by_other_branch_before_this_branch_look_back
+
             branch_versions_join = {
               Sequel[:verifications][:provider_version_id] => Sequel[:branch_versions][:version_id],
               Sequel[:branch_versions][:pacticipant_id] => provider_id
             }
-            join(:branch_versions, branch_versions_join) do
-              Sequel.lit("branch_versions.branch_name != ?", branch_name)
-            end
+            join(:branch_versions, branch_versions_join)
+              .where { Sequel[:verifications][:execution_date] >= recent_branch_cutoff }
+              .where { Sequel.lit("branch_versions.branch_name != ?", branch_name) }
           end
 
           def join_provider_versions_for_provider_id_and_branch(provider_id, provider_version_branch)
@@ -45,10 +51,13 @@ module PactBroker
       end
 
       def successfully_verified_by_provider_branch_when_not_wip(provider_id, provider_version_branch)
+        # Only check verifications from last N days (old verifications unlikely relevant for WIP)
+        recent_cutoff = DateTime.now - PactBroker.configuration.verified_by_other_branch_before_this_branch_look_back
         successful_verifications = VerificationForWipCalculations
                                      .select(:pact_version_id)
                                      .distinct
                                      .successful_non_wip_by_provider(provider_id)
+                                     .where { Sequel[:verifications][:execution_date] >= recent_cutoff }
                                      .join_provider_versions_for_provider_id_and_branch(provider_id, provider_version_branch)
 
 
@@ -65,8 +74,8 @@ module PactBroker
                                      .select(:pact_version_id)
                                      .distinct
                                      .successful_non_wip_by_provider(provider_id)
-                                     .join_branch_versions_excluding_branch(provider_id, provider_version_branch)
                                      .verified_before_creation_date_of(first_version_for_branch)
+                                     .join_branch_versions_excluding_branch(provider_id, provider_version_branch)
 
         from_self(alias: :pp)
           .select(Sequel[:pp].*)

data/lib/pact_broker/pacts/pacts_for_verification_repository.rb

@@ -57,7 +57,7 @@ module PactBroker
         end
 
         provider = pacticipant_repository.find_by_name(provider_name)
-        wip_start_date = options.fetch(:include_wip_pacts_since)
+        wip_start_date = determine_wip_start_date(provider, options)
 
         wip_by_consumer_tags = find_wip_pact_versions_for_provider_by_provider_tags(
           provider,
@@ -80,6 +80,94 @@ module PactBroker
 
       private
 
+      # Determine the WIP start date based on configuration and options
+      def determine_wip_start_date(provider, options)
+        dynamic_enabled = PactBroker.configuration.dynamic_wip_window_enabled?
+        logger.debug("Dynamic WIP window: #{dynamic_enabled ? 'enabled' : 'disabled'}") if logger.debug?
+        
+        if dynamic_enabled
+          calculate_wip_window(provider)
+        else
+          wip_start_date = options.fetch(:include_wip_pacts_since)
+          logger.debug("Using user-specified WIP window: #{wip_start_date}") if logger.debug?
+          wip_start_date
+        end
+      end
+
+      # Calculate optimal WIP window using P80 (80th percentile) of unverified pact ages
+      # Uses percentile instead of MAX to focus on active work and ignore abandoned pacts
+      # Returns: Date from N days ago (min 7 for weekly coverage, max 14 to align with query scope)
+      def calculate_wip_window(provider)
+        # Step 1: Get list of unverified pact ages in days (e.g., [2, 5, 7, 10, 12, 14])
+        unverified_ages = get_unverified_pact_ages_in_days(provider)
+        
+        # Step 2: If no unverified pacts, use default configured window
+        if unverified_ages.empty?
+          default_window = PactBroker.configuration.default_wip_window_days
+          logger.debug("No unverified pacts found for #{provider.name}, using default #{default_window}-day window") if logger.debug?
+          return Date.today - default_window
+        end
+
+        # Step 3: Calculate 80th percentile (ignore oldest 20% as abandoned work)
+        p80_age = percentile_80(unverified_ages)
+        
+        # Step 4: Ensure window is between configured min-max days, then return date
+        min_window = PactBroker.configuration.min_wip_window_days
+        max_window = PactBroker.configuration.max_wip_lookback_days
+        window_days = clamp_between(p80_age, min_window, max_window)
+        wip_start_date = Date.today - window_days
+        
+        if logger.debug?
+          logger.debug("Dynamic WIP window for #{provider.name}: found #{unverified_ages.size} unverified pacts, P80=#{p80_age} days, window=#{window_days} days (#{wip_start_date})")
+        end
+        
+        wip_start_date
+      rescue StandardError => e
+        default_window = PactBroker.configuration.default_wip_window_days
+        logger.error("Failed to calculate dynamic WIP window for provider #{provider.name}", error: e.class.name, message: e.message)
+        Date.today - default_window
+      end
+
+      # Get ages (in days) of pacts that haven't been successfully verified yet
+      # Only looks back the configured max_wip_lookback_days to keep query fast  
+      def get_unverified_pact_ages_in_days(provider)
+        max_days = PactBroker.configuration.max_wip_lookback_days
+        cutoff_date = DateTime.now - max_days
+        
+        # Use database-specific date arithmetic that works on both PostgreSQL and SQLite
+        # PostgreSQL: CURRENT_DATE - created_at::date returns integer days
+        # SQLite: julianday(date('now')) - julianday(date(created_at)) returns float days
+        db = PactPublication.db
+        age_expr = if db.database_type == :postgres
+                     Sequel.lit("CURRENT_DATE - ?::date", Sequel[:pact_publications][:created_at])
+                   else
+                     # SQLite
+                     Sequel.function(:julianday, Sequel.function(:date, "now")) -
+                     Sequel.function(:julianday, Sequel.function(:date, Sequel[:pact_publications][:created_at]))
+                   end
+        
+        PactPublication
+          .where(Sequel[:pact_publications][:provider_id] => provider.id)
+          .where { Sequel[:pact_publications][:created_at] >= cutoff_date }
+          .left_join(:verifications, { pact_version_id: :pact_version_id, success: true })
+          .where(Sequel[:verifications][:id] => nil)
+          .select_map { Sequel.cast(age_expr, :integer).as(:age_days) }
+          .compact
+      end
+
+      # Calculate 80th percentile: find value where 80% of data points are less than or equal
+      # Example: [2,3,5,7,10,12,14,20] → 80% index = 6 → value = 14
+      def percentile_80(values)
+        sorted = values.sort
+        index = [(sorted.length * 0.80).ceil - 1, 0].max
+        sorted[index]
+      end
+
+      # Constrain value between min and max bounds
+      def clamp_between(value, min, max)
+        [[value, max].min, min].max
+      end
+
       # Note: created_at is coming back as a string for sqlite
       # Can't work out how to to tell Sequel that this should be a date
       def to_datetime string_or_datetime
@@ -227,7 +315,7 @@ module PactBroker
 
       def find_wip_pact_versions_for_provider_by_provider_branch(provider_name, provider_version_branch, explicitly_specified_verifiable_pacts, options)
         provider = pacticipant_repository.find_by_name(provider_name)
-        wip_start_date = options.fetch(:include_wip_pacts_since)
+        wip_start_date = determine_wip_start_date(provider, options)
 
         potential_wip_by_consumer_branch = PactPublication.for_provider(provider).created_after(wip_start_date).for_all_branch_heads
         potential_wip_by_consumer_tag = PactPublication.for_provider(provider).created_after(wip_start_date).for_all_tag_heads

data/lib/pact_broker/pacts/repository.rb

@@ -149,7 +149,7 @@ module PactBroker
           query = query.overall_latest
         end
 
-        query.all.sort_by{ | p| p.consumer_name.downcase }.collect(&:to_head_pact)
+        query.all.sort.collect(&:to_head_pact)
       end
 
       def find_pacts_by_consumer_branch(provider_name, options = {})
@@ -179,7 +179,7 @@ module PactBroker
             query = query.for_branch_name(branch)
           end
         end
-        query.all.sort_by{ | p| p.consumer_name.downcase }.collect(&:to_head_pact)
+        query.all.sort.collect(&:to_head_pact)
       end
 
       def find_for_verification(provider_name, consumer_version_selectors)

data/lib/pact_broker/pacts/service.rb

@@ -210,7 +210,7 @@ module PactBroker
 
       # When no publication for the given consumer/provider/consumer version number exists
       def create_pact(params, version, provider)
-        logger.info("Creating new pact publication", params.without(:json_content))
+        logger.debug("Creating new pact publication", params.without(:json_content))
         logger.debug("Content #{params[:json_content]}")
         json_content = add_interaction_ids(params[:json_content])
         pact = pact_repository.create(

data/lib/pact_broker/tasks/clean_task.rb

@@ -10,7 +10,9 @@ module PactBroker
 
       attr_accessor :database_connection
       attr_reader :keep_version_selectors
+      attr_reader :keep_branch_selectors
       attr_accessor :version_deletion_limit
+      attr_accessor :branch_deletion_limit
       attr_accessor :logger
       attr_accessor :dry_run
       attr_accessor :use_lock # allow disabling of postgres lock if it is causing problems
@@ -21,6 +23,7 @@ module PactBroker
         @dry_run = false
         @use_lock = true
         @keep_version_selectors = PactBroker::DB::CleanIncremental::DEFAULT_KEEP_SELECTORS
+        @keep_branch_selectors = PactBroker::DB::CleanIncremental::DEFAULT_KEEP_BRANCH_SELECTORS
         rake_task(&block)
       end
 
@@ -31,10 +34,17 @@ module PactBroker
         end
       end
 
+      def keep_branch_selectors=(keep_branch_selectors)
+        require "pact_broker/db/clean/branch_selector"
+        @keep_branch_selectors = keep_branch_selectors.nil? ? nil : [*keep_branch_selectors].collect do | hash |
+          PactBroker::DB::Clean::BranchSelector.from_hash(hash)
+        end
+      end
+
       def rake_task &block
         namespace :pact_broker do
           namespace :db do
-            desc "Clean unnecessary pacts and verifications from database"
+            desc "Clean unnecessary pacts, verifications and stale branches from database"
             task :clean do | _t, _args |
               instance_eval(&block)
 
@@ -61,10 +71,14 @@ module PactBroker
           output "Deleting oldest #{version_deletion_limit} versions, keeping versions that match the configured selectors", keep_version_selectors.collect(&:to_hash)
         end
 
+        output_keep_branch_selectors
+
         start_time = Time.now
         results = PactBroker::DB::CleanIncremental.call(database_connection,
           keep: keep_version_selectors,
+          keep_branches: keep_branch_selectors,
           limit: version_deletion_limit,
+          branch_limit: branch_deletion_limit,
           logger: logger,
           dry_run: dry_run
         )
@@ -109,6 +123,14 @@ module PactBroker
         logger ? logger.info("#{prefix}#{string}", payload) : puts("#{prefix}#{string} #{payload.to_json}")
       end
 
+      def output_keep_branch_selectors
+        if keep_branch_selectors.nil? || keep_branch_selectors.empty?
+          output "Stale branch cleanup is disabled (no keep_branch_selectors configured)"
+        else
+          output "Deleting stale branches that do not match the configured selectors (main branches are always kept)", keep_branch_selectors.collect(&:to_hash)
+        end
+      end
+
       def add_defaults_to_keep_selectors
         if keep_version_selectors.none?(&:currently_deployed?)
           selector = PactBroker::DB::Clean::Selector.new(deployed: true)

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = "2.118.0"
+  VERSION = "2.120.0"
 end

data/lib/pact_broker/versions/branch_repository.rb

@@ -13,7 +13,7 @@ module PactBroker
         query = scope_for(Branch).where(pacticipant_id: pacticipant.id).select_all_qualified
         query = query.filter(:name, filter_options[:query_string]) if filter_options[:query_string]
         query
-          .order(Sequel.desc(:created_at), Sequel.desc(:id))
+          .order(Sequel.desc(:updated_at), Sequel.desc(:id))
           .eager(*eager_load_associations)
           .all_with_pagination_options(pagination_options)
       end

data/lib/pact_broker/versions/branch_service.rb

@@ -21,7 +21,7 @@ module PactBroker
         # @return [Array<PactBroker::Contracts::Notice>]
         def branch_deletion_notices(pacticipant, exclude:)
           count = branch_repository.count_branches_to_delete(pacticipant, exclude: exclude)
-          remaining = branch_repository.remaining_branches_after_future_deletion(pacticipant, exclude: exclude).sort_by(&:created_at).collect(&:name).join(", ")
+          remaining = branch_repository.remaining_branches_after_future_deletion(pacticipant, exclude: exclude).sort_by(&:updated_at).collect(&:name).join(", ")
           [PactBroker::Contracts::Notice.success(message("messages.branch.bulk_delete", count: count, pacticipant_name: pacticipant.name, remaining: remaining))]
         end
       end

data/lib/pact_broker/versions/branch_version_repository.rb

@@ -22,7 +22,7 @@ module PactBroker
       end
 
       def add_branch(version, branch_name, auto_created: false)
-        PactBroker.logger.info("BranchVersionRepository#add_branch method called with version #{version.inspect} and branch_name '#{branch_name}'")
+        PactBroker.logger.debug("BranchVersionRepository#add_branch method called with version #{version.inspect} and branch_name '#{branch_name}'")
         Sequel::Model.db.transaction do
           branch = find_or_create_branch(version.pacticipant, branch_name)
           branch_version = version.branch_version_for_branch(branch)
@@ -34,6 +34,7 @@ module PactBroker
             branch_version = PactBroker::Versions::BranchVersion.new(version: version, branch: branch, auto_created: auto_created).insert_ignore
             PactBroker::Versions::BranchHead.new(branch: branch, branch_version: branch_version).upsert
           end
+          branch.update(updated_at: Sequel.datetime_class.now)
           pacticipant_service.maybe_set_main_branch(version.pacticipant, branch_name)
           branch_version
         end

data/lib/pact_broker/webhooks/event_listener.rb

@@ -56,7 +56,7 @@ module PactBroker
         logger.debug("Event detected", event_name: event.name, event_comment: event.comment)
         if event.triggered_webhooks&.any?
           triggered_webhook_descriptions = event.triggered_webhooks.collect{ |tw| { event_name: event.name, webhook_uuid: tw.webhook_uuid, triggered_webhook_uuid: tw.uuid, webhook_description: tw.webhook.description } }
-          logger.info("Triggered webhooks for #{event.name}", triggered_webhooks: triggered_webhook_descriptions)
+          logger.debug("Triggered webhooks for #{event.name}", triggered_webhooks: triggered_webhook_descriptions)
         else
           logger.debug "No enabled webhooks found for event #{event.name}"
         end

data/lib/pact_broker/webhooks/execution_configuration.rb

@@ -53,6 +53,10 @@ module PactBroker
         with_updated_attribute(cert_store: value)
       end
 
+      def with_request_customizer(value)
+        with_updated_attribute(request_customizer: value)
+      end
+
       def webhook_context
         self[:webhook_context]
       end

data/lib/pact_broker/webhooks/redact_logs.rb

@@ -7,12 +7,12 @@ module PactBroker
 
       using PactBroker::StringRefinements
 
-      def redact_logs(logs, values)
-        RedactLogs.call(logs, values)
+      def redact_logs(logs, values, pattern_substitutions = [])
+        RedactLogs.call(logs, values, pattern_substitutions)
       end
 
-      def self.call logs, values
-        substitutions = HEADER_SUBSTITUTIONS + value_substitutions(values)
+      def self.call logs, values, pattern_substitutions = []
+        substitutions = HEADER_SUBSTITUTIONS + pattern_substitutions + value_substitutions(values)
 
         substitutions.reduce(logs) do | agg_logs, (find, replace) |
           agg_logs.gsub(find, replace)