pact_broker 2.109.0 → 2.110.0

data/lib/pact_broker/pacts/pact_publication_dataset_module.rb

@@ -57,6 +57,13 @@ module PactBroker
         end
       end
 
+      # Returns the latest pact for each branch, returning a pact for every branch, even if
+      # the most recent version of that branch does not have a pact.
+      # This is different from for_all_branch_heads, which will find the branch head versions,
+      # and return the pacts associated with those versions.
+      # This method should not be used for 'pacts for verification', because it will return
+      # a pact for branches where that integration should no longer exist.
+      # @return [Dataset<PactBroker::Pacts::PactPublication>]
       def latest_by_consumer_branch
         branch_versions_join = {
           Sequel[:pact_publications][:consumer_version_id] => Sequel[:branch_versions][:version_id]
@@ -111,10 +118,29 @@ module PactBroker
           .limit(1)
       end
 
-      # Return the pacts (if they exist) for the branch heads.
+      # Returns the pacts (if they exist) for all the branch heads.
+      # If the version for the branch head does not have a pact, then no pact is returned,
+      # (unlike latest_by_consumer_branch)
+      # This is much more performant than latest_by_consumer_branch and should be used
+      # for the 'pacts for verification' response
+      # @return [Dataset<PactBroker::Pacts::PactPublication>]
+      def for_all_branch_heads
+        base_query = self
+        base_query = base_query.join(:branch_heads, { Sequel[:bh][:version_id] => Sequel[:pact_publications][:consumer_version_id] }, { table_alias: :bh })
+
+        if no_columns_selected?
+          base_query = base_query.select_all_qualified.select_append(Sequel[:bh][:branch_name].as(:branch_name))
+        end
+
+        base_query.remove_overridden_revisions
+      end
+
+      # Return the pacts (if they exist) for the branch heads of the given branch names
       # This uses the new logic of finding the branch head and returning any associated pacts,
       # rather than the old logic of returning the pact for the latest version
       # on the branch that had a pact.
+      # @param [String] branch_name
+      # @return [Sequel::Dataset<PactBroker::Pacts::PactPublication>]
       def for_branch_heads(branch_name)
         branch_head_join = {
           Sequel[:pact_publications][:consumer_version_id] => Sequel[:branch_heads][:version_id],
@@ -173,7 +199,10 @@ module PactBroker
       # The latest pact publication for each tag
       # This uses the old logic of "the latest pact for a version that has a tag" (which always returns a pact)
       # rather than "the pact for the latest version with a tag"
-      # Need to see about updating this.
+      #
+      # For 'pacts for verification' this has been replaced by for_all_tag_heads
+      # This should only be used for the UI
+      # @return [Sequel::Dataset<PactBroker::Pacts::PactPublication>]
       def latest_by_consumer_tag
         tags_join = {
           Sequel[:pact_publications][:consumer_version_id] => Sequel[:tags][:version_id],
@@ -202,6 +231,7 @@ module PactBroker
       # This uses the old logic of "the latest pact for a version that has a tag" (which always returns a pact)
       # rather than "the pact for the latest version with a tag"
       # Need to see about updating this.
+      # @return [Sequel::Dataset<PactBroker::Pacts::PactPublication>]
       def latest_for_consumer_tag(tag_name)
         tags_join = {
           Sequel[:pact_publications][:consumer_version_id] => Sequel[:tags][:version_id],
@@ -252,6 +282,30 @@ module PactBroker
          .remove_overridden_revisions_from_complete_query
       end
 
+      # The pacts for the latest versions for each tag.
+      # Will not return a pact if the pact is no longer published for a particular tag
+      # NEW LOGIC
+      # @return [Sequel::Dataset<PactBroker::Pacts::PactPublication>]
+      def for_all_tag_heads
+        head_tags = PactBroker::Domain::Tag
+                      .select_group(:pacticipant_id, :name)
+                      .select_append{ max(version_order).as(:latest_version_order) }
+
+        head_tags_join = {
+          Sequel[:pact_publications][:consumer_id] => Sequel[:head_tags][:pacticipant_id],
+          Sequel[:pact_publications][:consumer_version_order] => Sequel[:head_tags][:latest_version_order]
+        }
+
+        base_query = self
+        if no_columns_selected?
+          base_query = base_query.select_all_qualified.select_append(Sequel[:head_tags][:name].as(:tag_name))
+        end
+
+        base_query
+          .join(head_tags, head_tags_join, { table_alias: :head_tags })
+         .remove_overridden_revisions_from_complete_query
+      end
+
       def in_environments
         currently_deployed_join = {
           Sequel[:pact_publications][:consumer_version_id] => Sequel[:currently_deployed_version_ids][:version_id]

data/lib/pact_broker/pacts/pact_publication_selector_dataset_module.rb

@@ -15,6 +15,7 @@ module PactBroker
 
         # Do the "latest" logic last so that the provider/consumer criteria get included in the "latest" query before the join, rather than after
         query = query.latest_for_main_branches if selector.latest_for_main_branch?
+        query = query.for_all_branch_heads if selector.latest_for_each_branch?
         query = query.latest_for_consumer_branch(selector.branch) if selector.latest_for_branch?
         query = query.for_latest_consumer_versions_with_tag(selector.tag) if selector.latest_for_tag?
         query = query.overall_latest if selector.overall_latest?

data/lib/pact_broker/pacts/pact_publication_wip_dataset_module.rb

@@ -1,35 +1,76 @@
 module PactBroker
   module Pacts
     module PactPublicationWipDatasetModule
+
+      # Use a cut down model of the verifications table just for the WIP calculations.
+      # Don't need all the associations and normal domain methods.
+      class VerificationForWipCalculations < Sequel::Model(:verifications)
+        dataset_module do
+          def successful_non_wip_by_provider(provider_id)
+            distinct.where(success: true, wip: false, provider_id: provider_id)
+          end
+
+          def verified_before_creation_date_of(record)
+            if record
+              verified_before_date(record.created_at)
+            else
+              self
+            end
+          end
+
+          def join_branch_versions_excluding_branch(provider_id, branch_name)
+            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
+          end
+
+          def join_provider_versions_for_provider_id_and_branch(provider_id, provider_version_branch)
+            branch_versions_join = {
+              Sequel[:verifications][:provider_version_id] => Sequel[:branch_versions][:version_id],
+              Sequel[:branch_versions][:pacticipant_id] => provider_id,
+              Sequel[:branch_versions][:branch_name] => provider_version_branch
+            }
+
+            join(:branch_versions, branch_versions_join)
+          end
+
+          def verified_before_date(date)
+            where { Sequel[:verifications][:execution_date] < date }
+          end
+        end
+      end
+
       def successfully_verified_by_provider_branch_when_not_wip(provider_id, provider_version_branch)
+        successful_verifications = VerificationForWipCalculations
+                                     .select(:pact_version_id)
+                                     .distinct
+                                     .successful_non_wip_by_provider(provider_id)
+                                     .join_provider_versions_for_provider_id_and_branch(provider_id, provider_version_branch)
+
+
         from_self(alias: :pp)
           .select(Sequel[:pp].*)
-          .where(Sequel[:pp][:provider_id] => provider_id)
-          .join_successful_non_wip_verifications_for_provider_id(provider_id)
-          .join_provider_versions_for_provider_id_and_branch(provider_id, provider_version_branch)
           .distinct
+          .join(successful_verifications, { Sequel[:pp][:pact_version_id] => Sequel[:v][:pact_version_id] }, { table_alias: :v })
       end
 
       def successfully_verified_by_provider_another_branch_before_this_branch_first_created(provider_id, provider_version_branch)
         first_version_for_branch = PactBroker::Domain::Version.first_for_pacticipant_id_and_branch(provider_id, provider_version_branch)
 
+        successful_verifications = VerificationForWipCalculations
+                                     .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)
+
         from_self(alias: :pp)
           .select(Sequel[:pp].*)
-          .join_successful_non_wip_verifications_for_provider_id(provider_id)
-          .join_provider_versions_for_provider_id(provider_id)
-          .join_branch_versions_excluding_branch(provider_version_branch)
-          .where(Sequel[:pp][:provider_id] => provider_id)
-          .verified_before_creation_date_of(first_version_for_branch)
-          .distinct
-      end
-
-      def join_branch_versions_excluding_branch(branch_name)
-        branch_versions_join = {
-          Sequel[:provider_versions][:id] => Sequel[:branch_versions][:version_id]
-        }
-        join(:branch_versions, branch_versions_join) do
-          Sequel.lit("branch_versions.branch_name != ?", branch_name)
-        end
+          .join(successful_verifications, { Sequel[:pp][:pact_version_id] => Sequel[:v][:pact_version_id] }, { table_alias: :v })
       end
 
       def successfully_verified_by_provider_tag_when_not_wip(provider_tag)
@@ -43,7 +84,6 @@ module PactBroker
           .select(Sequel[:pp].*)
           .join(:pact_version_provider_tag_successful_verifications, pact_version_provider_tag_verifications_join, { table_alias: :sv })
           .distinct
-
       end
 
       def successfully_verified_by_provider_another_tag_before_this_tag_first_created(provider_id, provider_tag)
@@ -71,66 +111,6 @@ module PactBroker
           end
           .distinct
       end
-
-      protected
-
-      def verified_before_date(date)
-        where { Sequel[:verifications][:execution_date] < date }
-      end
-
-      def join_successful_non_wip_verifications_for_provider_id(provider_id, &block)
-        verifications_join = {
-          pact_version_id: :pact_version_id,
-          Sequel[:verifications][:success] => true,
-          Sequel[:verifications][:wip] => false,
-          Sequel[:verifications][:provider_id] => provider_id
-        }
-        join(:verifications, verifications_join, {}, &block)
-      end
-
-      def join_provider_version_tags &block
-        tags_join = {
-          Sequel[:verifications][:provider_version_id] => Sequel[:provider_tags][:version_id],
-        }
-        join(:tags, tags_join, { table_alias: :provider_tags }, &block)
-      end
-
-      def join_provider_version_tags_for_tag(tag)
-        tags_join = {
-          Sequel[:verifications][:provider_version_id] => Sequel[:provider_tags][:version_id],
-          Sequel[:provider_tags][:name] => tag
-        }
-        join(:tags, tags_join, { table_alias: :provider_tags } )
-      end
-
-      def join_provider_versions_for_provider_id_and_branch(provider_id, provider_version_branch)
-        versions_join = {
-          Sequel[:verifications][:provider_version_id] => Sequel[:provider_versions][:id],
-          Sequel[:provider_versions][:pacticipant_id] => provider_id
-        }
-        branch_versions_join = {
-          Sequel[:provider_versions][:id] => Sequel[:branch_versions][:version_id],
-          Sequel[:branch_versions][:branch_name] => provider_version_branch
-        }
-        join(:versions, versions_join, { table_alias: :provider_versions } )
-          .join(:branch_versions, branch_versions_join)
-      end
-
-      def join_provider_versions_for_provider_id(provider_id, &block)
-        versions_join = {
-          Sequel[:verifications][:provider_version_id] => Sequel[:provider_versions][:id],
-          Sequel[:provider_versions][:pacticipant_id] => provider_id
-        }
-        join(:versions, versions_join, { table_alias: :provider_versions }, &block)
-      end
-
-      def verified_before_creation_date_of(record)
-        if record
-          verified_before_date(record.created_at)
-        else
-          self
-        end
-      end
     end
   end
 end

data/lib/pact_broker/pacts/pacts_for_verification_repository.rb

@@ -7,6 +7,7 @@ require "pact_broker/pacts/selector"
 require "pact_broker/pacts/selectors"
 require "pact_broker/feature_toggle"
 require "pact_broker/repositories/scopes"
+require "pact_broker/matrix/unresolved_selector"
 
 module PactBroker
   module Pacts
@@ -63,7 +64,7 @@ module PactBroker
           provider_tags_names,
           wip_start_date,
           explicitly_specified_verifiable_pacts,
-          :latest_by_consumer_tag
+          :for_all_tag_heads
         )
 
         wip_by_consumer_branches = find_wip_pact_versions_for_provider_by_provider_tags(
@@ -71,7 +72,7 @@ module PactBroker
           provider_tags_names,
           wip_start_date,
           explicitly_specified_verifiable_pacts,
-          :latest_by_consumer_branch
+          :for_all_branch_heads
         )
 
         deduplicate_verifiable_pacts(wip_by_consumer_tags + wip_by_consumer_branches).sort
@@ -228,8 +229,8 @@ module PactBroker
         provider = pacticipant_repository.find_by_name(provider_name)
         wip_start_date = options.fetch(:include_wip_pacts_since)
 
-        potential_wip_by_consumer_branch = PactPublication.for_provider(provider).created_after(wip_start_date).latest_by_consumer_branch
-        potential_wip_by_consumer_tag = PactPublication.for_provider(provider).created_after(wip_start_date).latest_by_consumer_tag
+        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
 
         log_debug_for_wip do
           log_pact_publications_from_query("Potential WIP pacts for provider branch #{provider_version_branch} created after #{wip_start_date} by consumer branch", potential_wip_by_consumer_branch)

data/lib/pact_broker/pacts/repository.rb

@@ -33,8 +33,8 @@ module PactBroker
         scope
       end
 
-      def create params
-        integration_repository.create_for_pact(params.fetch(:consumer_id), params.fetch(:provider_id))
+      # @return [PactBroker::Domain::Pact]
+      def create(params)
         pact_version = find_or_create_pact_version(
           params.fetch(:consumer_id),
           params.fetch(:provider_id),

data/lib/pact_broker/pacts/selector.rb

@@ -31,6 +31,8 @@ module PactBroker
       def type
         if latest_for_main_branch?
           :latest_for_main_branch
+        elsif latest_for_each_branch?
+          :latest_for_each_branch
         elsif latest_for_branch?
           :latest_for_branch
         elsif matching_branch?
@@ -265,12 +267,16 @@ module PactBroker
       # Not sure if the fallback_tag logic is needed
       def latest_for_branch? potential_branch = nil
         if potential_branch
-          !!(latest && branch == potential_branch)
+          latest == true && branch == potential_branch
         else
-          !!(latest && !!branch)
+          latest == true && branch.is_a?(String)
         end
       end
 
+      def latest_for_each_branch?
+        latest == true && branch == true
+      end
+
       def all_for_tag_and_consumer?
         !!(tag && !latest? && consumer)
       end

data/lib/pact_broker/tasks/clean_task.rb

@@ -1,3 +1,8 @@
+# This task is used to clean up old data in a Pact Broker database
+# to stop performance issues from slowing down responses when there is
+# too much data.
+# See https://docs.pact.io/pact_broker/administration/maintenance
+
 module PactBroker
   module DB
     class CleanTask < ::Rake::TaskLib
@@ -7,11 +12,13 @@ module PactBroker
       attr_accessor :version_deletion_limit
       attr_accessor :logger
       attr_accessor :dry_run
+      attr_accessor :use_lock # allow disabling of postgres lock if it is causing problems
 
       def initialize &block
         require "pact_broker/db/clean_incremental"
         @version_deletion_limit = 1000
         @dry_run = false
+        @use_lock = true
         @keep_version_selectors = PactBroker::DB::CleanIncremental::DEFAULT_KEEP_SELECTORS
         rake_task(&block)
       end
@@ -28,42 +35,77 @@ module PactBroker
           namespace :db do
             desc "Clean unnecessary pacts and verifications from database"
             task :clean do | _t, _args |
-
               instance_eval(&block)
 
-              require "pact_broker/db/clean_incremental"
-              require "pact_broker/error"
-              require "yaml"
-              require "benchmark"
+              with_lock do
+                perform_clean
+              end
+            end
+          end
+        end
+      end
+
+      def perform_clean
+        require "pact_broker/db/clean_incremental"
+        require "pact_broker/error"
+        require "yaml"
+        require "benchmark"
 
-              raise PactBroker::Error.new("You must specify the version_deletion_limit") unless version_deletion_limit
+        raise PactBroker::Error.new("You must specify the version_deletion_limit") unless version_deletion_limit
 
-              prefix = dry_run ? "[DRY RUN] " : ""
+        if keep_version_selectors.nil? || keep_version_selectors.empty?
+          raise PactBroker::Error.new("You must specify which versions to keep")
+        else
+          add_defaults_to_keep_selectors
+          output "Deleting oldest #{version_deletion_limit} versions, keeping versions that match the configured selectors", keep_version_selectors.collect(&:to_hash)
+        end
 
-              if keep_version_selectors.nil? || keep_version_selectors.empty?
-                raise PactBroker::Error.new("You must specify which versions to keep")
-              else
-                add_defaults_to_keep_selectors
-                output "#{prefix}Deleting oldest #{version_deletion_limit} versions, keeping versions that match the configured selectors", keep_version_selectors.collect(&:to_hash)
-              end
+        start_time = Time.now
+        results = PactBroker::DB::CleanIncremental.call(database_connection,
+          keep: keep_version_selectors,
+          limit: version_deletion_limit,
+          logger: logger,
+          dry_run: dry_run
+        )
+        end_time = Time.now
+        elapsed_seconds = (end_time - start_time).to_i
+        output "Results (#{elapsed_seconds} seconds)", results
+      end
 
-              start_time = Time.now
-              results = PactBroker::DB::CleanIncremental.call(database_connection,
-                keep: keep_version_selectors,
-                limit: version_deletion_limit,
-                logger: logger,
-                dry_run: dry_run
-              )
-              end_time = Time.now
-              elapsed_seconds = (end_time - start_time).to_i
-              output "Results (#{elapsed_seconds} seconds)", results
-            end
+      # Use a Postgres advisory lock to ensure that only one clean can run at a time.
+      # This allows a cron schedule to be used on the Pact Broker Docker image when deployed
+      # on a multi-instance architecture, without all the instances stepping on each other's toes.
+      #
+      # Any tasks that attempt to run while a clean job is running will skip the clean
+      # and exit with a message and a success code.
+      #
+      # To test that the lock works, run:
+      #   script/docker/db-start.sh
+      #   script/docker/db-migrate.sh
+      #   for i in {0..3}; do PACT_BROKER_TEST_DATABASE_URL=postgres://postgres:postgres@localhost/postgres bundle exec rake pact_broker:db:clean &;  done;
+      #
+      # There will be 3 messages saying "Clean was not performed" and output from one thread showing the clean is being done.
+      def with_lock
+        if use_lock
+          require "pact_broker/db/advisory_lock"
+
+          lock = PactBroker::DB::AdvisoryLock.new(database_connection, :clean, :pg_try_advisory_lock)
+          results = lock.with_lock do
+            yield
+          end
+
+          if !lock.lock_obtained?
+            output("Clean was not performed as a clean is already in progress. Exiting.")
           end
+          results
+        else
+          yield
         end
       end
 
-      def output string, payload = {}
-        logger ? logger.info(string, payload) : puts("#{string} #{payload.to_json}")
+      def output(string, payload = {})
+        prefix = dry_run ? "[DRY RUN] " : ""
+        logger ? logger.info("#{prefix}#{string}") : puts("#{prefix}#{string} #{payload.to_json}")
       end
 
       def add_defaults_to_keep_selectors

data/lib/pact_broker/test/test_data_builder.rb

@@ -43,7 +43,6 @@ module PactBroker
       include PactBroker::Services
       using PactBroker::StringRefinements
 
-
       attr_reader :pacticipant
       attr_reader :consumer
       attr_reader :provider
@@ -192,8 +191,11 @@ module PactBroker
         self
       end
 
+      # Create an Integration object for the current consumer and provider
+      # @return [PactBroker::Test::TestDataBuilder]
       def create_integration
-        PactBroker::Integrations::Repository.new.create_for_pact(consumer.id, provider.id)
+        @integration = PactBroker::Integrations::Repository.new.create_for_pact(consumer.id, provider.id)
+        set_created_at_if_set(@now, :integrations, { consumer_id: consumer.id, provider_id: provider.id })
         self
       end
 
@@ -280,7 +282,9 @@ module PactBroker
         self
       end
 
-      def create_pact params = {}
+      # Creates a pact (and integration if one does not already exist) from the given params
+      # @return [PactBroker::Test::TestDataBuilder]
+      def create_pact(params = {})
         params.delete(:comment)
         json_content = params[:json_content] || default_json_content
         pact_version_sha = params[:pact_version_sha] || generate_pact_version_sha(json_content)
@@ -293,6 +297,7 @@ module PactBroker
           json_content: prepare_json_content(json_content),
           version: @consumer_version
         )
+        integration_service.handle_bulk_contract_data_published([@pact])
         pact_versions_count_after = PactBroker::Pacts::PactVersion.count
         set_created_at_if_set(params[:created_at], :pact_publications, id: @pact.id)
         set_created_at_if_set(params[:created_at], :pact_versions, sha: @pact.pact_version_sha) if pact_versions_count_after > pact_versions_count_before

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = "2.109.0"
+  VERSION = "2.110.0"
 end

data/lib/pact_broker/versions/branch_service.rb

@@ -2,6 +2,7 @@ require "forwardable"
 require "pact_broker/logging"
 require "pact_broker/repositories"
 require "pact_broker/messages"
+require "pact_broker/contracts/notice"
 
 module PactBroker
   module Versions

data/lib/pact_broker/versions/repository.rb

@@ -57,29 +57,11 @@ module PactBroker
           .single_record
       end
 
-      # The eager loaded relations are hardcoded here to support the PactBroker::Api::Decorators::VersionDecorator
-      # Newer "find all" implementations for other models pass the relations to eager load in
-      # from the decorator via the resource.
-      def find_all_pacticipant_versions_in_reverse_order name, pagination_options = {}
-        pacticipant = pacticipant_repository.find_by_name!(name)
-        query = PactBroker::Domain::Version
-                  .where(pacticipant: pacticipant)
-                  .eager(:pacticipant)
-                  .eager(branch_versions: [:version, :branch_head, { branch: :pacticipant }])
-                  .eager(tags: :head_tag)
-                  .eager(:pact_publications)
-                  .reverse_order(:order)
-        query.all_with_pagination_options(pagination_options)
-      end
-
-      def find_pacticipant_versions_in_reverse_order(pacticipant_name, options = {}, pagination_options = {})
+      def find_pacticipant_versions_in_reverse_order(pacticipant_name, options = {}, pagination_options = {}, eager_load_associations = [])
         pacticipant = pacticipant_repository.find_by_name!(pacticipant_name)
         query = PactBroker::Domain::Version
                   .where(pacticipant: pacticipant)
-                  .eager(:pacticipant)
-                  .eager(branch_versions: [:version, :branch_head, { branch: :pacticipant }])
-                  .eager(tags: :head_tag)
-                  .eager(:pact_publications)
+                  .eager(*eager_load_associations)
                   .reverse_order(:order)
 
         if options[:branch_name]

data/lib/pact_broker/versions/service.rb

@@ -26,12 +26,8 @@ module PactBroker
         version_repository.find_latest_by_pacticipant_name_and_branch_name(pacticipant_name, branch_name)
       end
 
-      def self.find_all_pacticipant_versions_in_reverse_order(name, pagination_options = {})
-        version_repository.find_all_pacticipant_versions_in_reverse_order(name, pagination_options)
-      end
-
-      def self.find_pacticipant_versions_in_reverse_order(pacticipant_name, options, pagination_options = {})
-        version_repository.find_pacticipant_versions_in_reverse_order(pacticipant_name, options, pagination_options)
+      def self.find_pacticipant_versions_in_reverse_order(pacticipant_name, options, pagination_options = {}, eager_load_associations = [])
+        version_repository.find_pacticipant_versions_in_reverse_order(pacticipant_name, options, pagination_options, eager_load_associations)
       end
 
       def self.create_or_overwrite(pacticipant_name, version_number, version)

data/lib/pact_broker/webhooks/execution.rb

@@ -2,14 +2,14 @@ require "pact_broker/dataset"
 
 module PactBroker
   module Webhooks
-    class Execution < Sequel::Model(
-      Sequel::Model.db[:webhook_executions].select(
-        Sequel[:webhook_executions][:id],
-        :triggered_webhook_id,
-        :success,
-        :logs,
-        Sequel[:webhook_executions][:created_at])
-      )
+    class Execution < Sequel::Model(:webhook_executions)
+      # Ignore the columns that were used before the TriggeredWebhook class existed.
+      # It used to go Webhook -> Execution, and now it goes Webhook -> TriggeredWebhook -> Execution
+      # If we ever release a major version where we drop unused columns, those columns could be deleted.
+      EXECUTION_COLUMNS = Sequel::Model.db.schema(:webhook_executions).collect(&:first) - [:webhook_id, :pact_publication_id, :consumer_id, :provider_id]
+
+      set_dataset(Sequel::Model.db[:webhook_executions].select(*EXECUTION_COLUMNS))
+
       set_primary_key :id
       plugin :timestamps