pact_broker 2.107.1 → 2.109.0

data/lib/pact_broker/matrix/resolved_selector.rb

@@ -4,7 +4,9 @@ require "pact_broker/hash_refinements"
 # This is created from either specified or inferred data, based on the user's query
 # eg.
 # can-i-deploy --pacticipant Foo --version 1 (this is a specified selector)
-#              --to prod (this is used to create inferred selectors)
+#              --to prod (this is used to create inferred selectors, one for each integrated pacticipant in that environment)
+# When an UnresolvedSelector specifies multiple application versions (eg. { tag: "prod" }) then a ResolvedSelector
+# is created for every Version object found for the original selector.
 
 module PactBroker
   module Matrix
@@ -31,6 +33,9 @@ module PactBroker
         )
       end
 
+      # This is not possible for specified selectors, as there is validation at the HTTP query level to
+      # ensure that all pacticipants in the specified selectors exist.
+      # It is possible for the ignore selectors however.
       def self.for_non_existing_pacticipant(original_selector, type, ignore)
         ResolvedSelector.new(
           pacticipant_id: NULL_PACTICIPANT_ID,
@@ -187,16 +192,20 @@ module PactBroker
         !ignore?
       end
 
+      def original_selector
+        self[:original_selector]
+      end
+
       # rubocop: disable Metrics/CyclomaticComplexity, Metrics/MethodLength
       def description
         if latest_tagged? && pacticipant_version_number
           "the latest version of #{pacticipant_name} with tag #{tag} (#{pacticipant_version_number})"
         elsif latest_tagged?
           "the latest version of #{pacticipant_name} with tag #{tag} (no such version exists)"
-        elsif main_branch? && pacticipant_version_number.nil?
-          "a version of #{pacticipant_name} from the main branch (no such version exists)"
         elsif latest_from_main_branch? && pacticipant_version_number.nil?
-          "the latest version of #{pacticipant_name} from the main branch (no such verison exists)"
+          "the latest version of #{pacticipant_name} from the main branch (no versions exist for this branch)"
+        elsif main_branch? && pacticipant_version_number.nil?
+          "any version of #{pacticipant_name} from the main branch (no versions exist for this branch)"
         elsif latest_from_branch? && pacticipant_version_number
           "the latest version of #{pacticipant_name} from branch #{branch} (#{pacticipant_version_number})"
         elsif latest_from_branch?

data/lib/pact_broker/matrix/resolved_selector_builder.rb

@@ -0,0 +1,84 @@
+# Builds a PactBroker::Matrix::UnresolvedSelector based on the given
+# UnresolvedSelector, selector type, Pacticipant and Version objects,
+# using the selector_ignorer to work out if the built ResolvedSelector
+# should be marked as ignored or not.
+
+module PactBroker
+  module Matrix
+    class ResolvedSelectorBuilder
+
+      attr_accessor :pacticipant, :versions
+
+      # @param [PactBroker::Matrix::UnresolvedSelector] unresolved_selector
+      # @param [Symbol] selector_type :specified or :inferred
+      # @param [PactBroker::Matrix::Ignorer] selector_ignorer
+      def initialize(unresolved_selector, selector_type, selector_ignorer)
+        @unresolved_selector = unresolved_selector
+        @selector_type = selector_type
+        @selector_ignorer = selector_ignorer
+      end
+
+      def build
+        if pacticipant && versions
+          build_resolved_selectors_for_versions(pacticipant, versions, unresolved_selector, selector_type)
+        elsif pacticipant
+          selector_for_all_versions_of_a_pacticipant(pacticipant, unresolved_selector, selector_type)
+        else
+          build_selector_for_non_existing_pacticipant(unresolved_selector, selector_type)
+        end
+      end
+
+      private
+
+      attr_reader :unresolved_selector, :selector_type, :selector_ignorer
+
+      # When a single selector specifies multiple versions (eg. "all prod pacts"), this expands
+      # the single selector into one selector for each version.
+      # When a pacticipant is found, but there are no versions matching the selector,
+      # the versions array will be have a single item which is nil (`[nil]`).
+      # See PactBroker::Matrix::SelectorResolver#find_versions_for_selector
+      # There may be a better way to pass in this information.
+      def build_resolved_selectors_for_versions(pacticipant, versions, unresolved_selector, selector_type)
+        one_of_many = versions.compact.size > 1
+        versions.collect do | version |
+          if version
+            selector_for_found_version(pacticipant, version, unresolved_selector, selector_type, one_of_many)
+          else
+            selector_for_non_existing_version(pacticipant, unresolved_selector, selector_type)
+          end
+        end
+      end
+
+      def selector_for_non_existing_version(pacticipant, unresolved_selector, selector_type)
+        ignore = selector_ignorer.ignore_pacticipant?(pacticipant)
+        ResolvedSelector.for_pacticipant_and_non_existing_version(pacticipant, unresolved_selector, selector_type, ignore)
+      end
+
+      def selector_for_found_version(pacticipant, version, unresolved_selector, selector_type, one_of_many)
+        ResolvedSelector.for_pacticipant_and_version(
+          pacticipant,
+          version,
+          unresolved_selector,
+          selector_type,
+          selector_ignorer.ignore_pacticipant_version?(pacticipant, version),
+          one_of_many
+        )
+      end
+
+      def selector_for_all_versions_of_a_pacticipant(pacticipant, unresolved_selector, selector_type)
+        ResolvedSelector.for_pacticipant(
+          pacticipant,
+          unresolved_selector,
+          selector_type,
+          selector_ignorer.ignore_pacticipant?(pacticipant)
+        )
+      end
+
+      # only relevant for ignore selectors, validation stops this happening for the normal
+      # selectors
+      def build_selector_for_non_existing_pacticipant(unresolved_selector, selector_type)
+        ResolvedSelector.for_non_existing_pacticipant(unresolved_selector, selector_type, false)
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/resolved_selectors_builder.rb

@@ -0,0 +1,39 @@
+require "pact_broker/matrix/selector_resolver"
+
+# Builds the array of ResolvedSelector objects using the
+# ignore selectors, the specified selectors, and the inferred integrations.
+
+module PactBroker
+  module Matrix
+    class ResolvedSelectorsBuilder
+      attr_reader :ignore_selectors, :specified_selectors, :inferred_selectors
+
+      def initialize
+        @inferred_selectors = []
+      end
+
+      # @param [Array<PactBroker::Matrix::UnresolvedSelector>]
+      # @param [Hash] options
+      def resolve_selectors(unresolved_specified_selectors, unresolved_ignore_selectors)
+        # must do this first because we need the ignore selectors to resolve the specified selectors
+        @ignore_selectors = SelectorResolver.resolved_ignore_selectors(unresolved_ignore_selectors)
+        @specified_selectors = SelectorResolver.resolve_specified_selectors(unresolved_specified_selectors, ignore_selectors)
+      end
+
+      # Use the given Integrations to work out what the selectors are for the versions that the versions for the specified
+      # selectors should be deployed with.
+      # eg. For `can-i-deploy --pacticipant Foo --version adfjkwejr --to-environment prod`, work out the selectors for the integrated application
+      # versions in the prod environment.
+      # @param [Array<PactBroker::Matrix::Integration>] integrations
+      def resolve_inferred_selectors(integrations, options)
+        @inferred_selectors = SelectorResolver.resolve_inferred_selectors(specified_selectors, ignore_selectors, integrations, options)
+      end
+
+      # All the resolved selectors to be used in the matrix query, specified and inferred (if any)
+      # @return [Array<PactBroker::Matrix::ResolvedSelector>]
+      def all_selectors
+        specified_selectors + inferred_selectors
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/row_ignorer.rb

@@ -0,0 +1,36 @@
+module PactBroker
+  module Matrix
+    class RowIgnorer
+
+      class << self
+        # Splits the matrix rows into considered rows and ignored rows, based on the
+        # ignore selectors specified by the user in the can-i-deploy command (eg. --ignore SomeProviderThatIsNotReadyYet).
+        # @param [Array<MatrixRow, EveryRow>] rows
+        # @param [<PactBroker::Matrix::ResolvedSelector>] resolved_ignore_selectors
+        # @return [Array<MatrixRow, EveryRow>] considered_rows, [Array<MatrixRow, EveryRow>] ignored_rows
+        def split_rows_into_considered_and_ignored(rows, resolved_ignore_selectors)
+          if resolved_ignore_selectors.any?
+            considered, ignored = [], []
+            rows.each do | row |
+              if ignore_row?(resolved_ignore_selectors, row)
+                ignored << row
+              else
+                considered << row
+              end
+            end
+            return considered, ignored
+          else
+            return rows, []
+          end
+        end
+
+        def ignore_row?(resolved_ignore_selectors, row)
+          resolved_ignore_selectors.any? do | s |
+            s.pacticipant_id == row.consumer_id  && (s.only_pacticipant_name_specified? || s.pacticipant_version_id == row.consumer_version_id) ||
+              s.pacticipant_id == row.provider_id  && (s.only_pacticipant_name_specified? || s.pacticipant_version_id == row.provider_version_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/selector_ignorer.rb

@@ -0,0 +1,59 @@
+# This class determines whether or not a resolved selector (both specified and inferred)
+# that is about to be created should be marked as "ignored".
+# It uses the ignore selectors are provided in the can-i-deploy CLI command like so:
+#   can-i-deploy --pacticipant Foo --version 234243 --to-environment prod --ignore SomeProviderThatIsNotReadyYet [--version SomeOptionalVersion]
+# The ignored flag on the ResolvedSelector is used to determine whether or not a failing/missing row
+# in the can-i-deploy matrix should be ignored.
+# This allows can-i-deploy to pass successfully when a dependency is known to be not ready,
+# but the developer wants to deploy the application anyway.
+
+# The only reason why we need to resolve the ignore selectors is that we check in PactBroker::Matrix::DeploymentStatusSummary
+# whether or not the pacticipant or version they specify actually exist.
+# We could actually have performed the ignore checks just using the name and version number.
+
+module PactBroker
+  module Matrix
+    class SelectorIgnorer
+
+      # @param [Array<PactBroker::Matrix::UnresolvedSelector>] resolved_ignore_selectors
+      def initialize(resolved_ignore_selectors)
+        @resolved_ignore_selectors = resolved_ignore_selectors
+      end
+
+      # Whether the pacticipant should be ignored if the verification results are missing/failed.
+      # @param [PactBroker::Domain::Pacticipant] pacticipant
+      # @return [Boolean]
+      def ignore_pacticipant?(pacticipant)
+        resolved_ignore_selectors.any? do | s |
+          s.pacticipant_id == pacticipant.id && s.only_pacticipant_name_specified?
+        end
+      end
+
+      # Whether the pacticipant version should be ignored if the verification results are missing/failed.
+      # @param [PactBroker::Domain::Pacticipant] pacticipant
+      # @param [PactBroker::Domain::Version] version
+      # @return [Boolean]
+      def ignore_pacticipant_version?(pacticipant, version)
+        resolved_ignore_selectors.any? do | s |
+          s.pacticipant_id == pacticipant.id && (s.only_pacticipant_name_specified? || s.pacticipant_version_id == version.id)
+        end
+      end
+
+      private
+
+      attr_reader :resolved_ignore_selectors
+    end
+
+    # Used when resolving the ignore selecors in the first place - the process for resolving normal selectors
+    # and ignore selectors is almost the same, but it makes no sense to ignore an ignore selector.
+    class NilSelectorIgnorer
+      def ignore_pacticipant?(*)
+        false
+      end
+
+      def ignore_pacticipant_version?(*)
+        false
+      end
+    end
+  end
+end

data/lib/pact_broker/matrix/selector_resolver.rb

@@ -0,0 +1,130 @@
+require "pact_broker/repositories"
+require "pact_broker/matrix/resolved_selector"
+require "pact_broker/matrix/resolved_selector_builder"
+require "pact_broker/matrix/selector_ignorer"
+
+
+# Take the selectors and options provided by the user (eg. [{ pacticipant_name: "Foo", pacticipant_version_number: "1" }], { to_environment: "prod" })
+# that use pacticipant/version/branch/environment names,
+# and look up the IDs of all the objects, and return them as ResolvedSelector objects.
+# For unresolved selectors that specify a collection of versions (eg. { branch: "main" }) a ResolvedSelector
+# will be returned for every pacticipant version found. This will eventually be used in the can-i-deploy
+# logic in PactBroker::Matrix::DeploymentStatusSummary to work out if there are any missing verifications.
+
+module PactBroker
+  module Matrix
+    class SelectorResolver
+      class << self
+        include PactBroker::Repositories
+
+        # Resolve any ignore selectors used in the can-i-deploy command e.g `--ignore SomeProviderThatIsNotReadyYet`
+        # @param [Array<PactBroker::Matrix::UnresolvedSelector>] unresolved_ignore_selectors
+        # @return [Array<PactBroker::Matrix::ResolvedSelector>]
+        def resolved_ignore_selectors(unresolved_ignore_selectors)
+          # When resolving the ignore_selectors, use the NilSelectorIgnorer because it doesn't make sense to ignore
+          # the ignore selectors.
+          resolve_versions_and_add_ids(unresolved_ignore_selectors, :ignored, NilSelectorIgnorer.new)
+        end
+
+        # Resolve the selectors that were specified in the can-i-deploy command eg. `--pacticipant Foo --version 43434`
+        # There may be one or multiple.
+        # @param [Array<PactBroker::Matrix::UnresolvedSelector>] unresolved_specified_selectors
+        # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_ignore_selectors previously resolved selectors for the versions to ignore
+        # @return [Array<PactBroker::Matrix::ResolvedSelector>]
+        def resolve_specified_selectors(unresolved_specified_selectors, resolved_ignore_selectors)
+          resolve_versions_and_add_ids(unresolved_specified_selectors, :specified, SelectorIgnorer.new(resolved_ignore_selectors))
+        end
+
+        # When the can-i-deploy command uses any of the `--to` options (eg. `--to-environment ENV` or `--to TAG`)
+        # we need to create the inferred selectors for the pacticipant versions in that environment/with that tag/branch.
+        # eg. if A -> B, and the CLI command is `can-i-deploy --pacticipant A --version 3434 --to-environment prod`,
+        # then we need to make the inferred selector for pacticipant B with the version that is in prod.
+        # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_specified_selectors
+        # @param [Array<PactBroker::Matrix::ResolvedSelector>] resolved_ignore_selectors
+        # @param [Array<PactBroker::Matrix::Integration>] integrations
+        # @param [Hash] options
+        # @return [Array<PactBroker::Matrix::ResolvedSelector>]
+        def resolve_inferred_selectors(resolved_specified_selectors, resolved_ignore_selectors, integrations, options)
+          all_pacticipant_names = integrations.collect(&:pacticipant_names).flatten.uniq
+          specified_names = resolved_specified_selectors.collect{ |s| s[:pacticipant_name] }
+          inferred_pacticipant_names = all_pacticipant_names - specified_names
+          unresolved_selectors = build_unresolved_selectors_for_inferred_pacticipants(inferred_pacticipant_names, options)
+          resolve_versions_and_add_ids(unresolved_selectors, :inferred, SelectorIgnorer.new(resolved_ignore_selectors))
+        end
+
+        # Find the IDs of every pacticipant and version in the UnresolvedSelectors, and return them as ResolvedSelectors,
+        # expanding selectors for multiple versions.
+        # This gets called first for the ignore selectors, then the specified selectors, and then the inferred selectors.
+        # When it gets called for the first time for the ignore selectors, they will be passed in as the unresolved_selectors, and the resolved_ignore_selectors
+        # will be empty.
+        # The next times it is called with the specified selectors and the inferred selectors, the previously resolved ignore selectors will be passed in
+        # as resolved_ignore_selectors so we can work out which of those selectors needs to be ignored.
+        #
+        # @param [Array<PactBroker::Matrix::UnresolvedSelector>] unresolved_selectors
+        # @param [Symbol] selector_type which may be :specified or :inferred
+        # @param [SelectorIgnorer] selector_ignorer
+        # @return [Array<PactBroker::Matrix::ResolvedSelector>]
+        def resolve_versions_and_add_ids(unresolved_selectors, selector_type, selector_ignorer)
+          pacticipants_hash = find_pacticipants_for_selectors(unresolved_selectors)
+          unresolved_selectors.collect do | unresolved_selector |
+            build_selectors(pacticipants_hash, unresolved_selector, selector_type, selector_ignorer)
+          end.flatten
+        end
+
+        private :resolve_versions_and_add_ids
+
+        # Return a Hash of the pacticipant names used in the selectors, where the key is the name and the value is the pacticipant
+        # @return [Hash<String, PactBroker::Domain::Pacticipant>]
+        def find_pacticipants_for_selectors(unresolved_selectors)
+          names = unresolved_selectors.collect(&:pacticipant_name)
+          PactBroker::Domain::Pacticipant.where(name: names).all.group_by(&:name).transform_values(&:first)
+        end
+
+        private :find_pacticipants_for_selectors
+
+        def build_selectors(pacticipants_hash, unresolved_selector, selector_type, selector_ignorer)
+          selector_builder = ResolvedSelectorBuilder.new(unresolved_selector, selector_type, selector_ignorer)
+          selector_builder.pacticipant = pacticipants_hash[unresolved_selector.pacticipant_name]
+          if selector_builder.pacticipant
+            versions = find_versions_for_selector(unresolved_selector)
+            selector_builder.versions = versions
+          end
+          selector_builder.build
+        end
+
+        # Find the pacticipant versions for the unresolved selector.
+        # @param [PactBroker::Matrix::UnresolvedSelector] unresolved_selector
+        def find_versions_for_selector(unresolved_selector)
+          # For selectors that just set the pacticipant name, there's no need to resolve the version -
+          # only the pacticipant ID will be used in the query
+          return nil if unresolved_selector.all_for_pacticipant?
+          versions = version_repository.find_versions_for_selector(unresolved_selector)
+
+          if unresolved_selector.latest
+            [versions.first]
+          else
+            versions.empty? ? [nil] : versions
+          end
+        end
+
+        private :find_versions_for_selector
+
+        # Build an unresolved selector for the integrations that we have inferred for the target environment/branch/tag
+        # @param [Array<String>] inferred_pacticipant_names the names of the pacticipants that we have determined to be integrated with the versions for the specified selectors
+        def build_unresolved_selectors_for_inferred_pacticipants(inferred_pacticipant_names, options)
+          inferred_pacticipant_names.collect do | pacticipant_name |
+            selector = UnresolvedSelector.new(pacticipant_name: pacticipant_name)
+            selector.tag = options[:tag] if options[:tag]
+            selector.branch = options[:branch] if options[:branch]
+            selector.main_branch = options[:main_branch] if options[:main_branch]
+            selector.latest = options[:latest] if options[:latest]
+            selector.environment_name = options[:environment_name] if options[:environment_name]
+            selector
+          end
+        end
+
+        private :build_unresolved_selectors_for_inferred_pacticipants
+      end
+    end
+  end
+end

data/lib/pact_broker/metrics/service.rb

@@ -101,8 +101,8 @@ module PactBroker
       end
 
       def pact_revision_counts
-        query = "select revision_count as number_of_revisions, count(consumer_version_id) as consumer_version_count
-          from (select consumer_version_id, count(*) as revision_count from pact_publications group by consumer_version_id) foo
+        query = "select revision_count as number_of_revisions, count(*) as consumer_version_count
+          from (select count(*) as revision_count from pact_publications group by consumer_version_id, provider_id) foo
           group by revision_count
           order by 1"
         PactBroker::Pacts::PactPublication.db[query].all.each_with_object({}) { |row, hash| hash[row[:number_of_revisions]] = row[:consumer_version_count] }
@@ -116,14 +116,9 @@ module PactBroker
           PactBroker::Pacts::PactPublication.db[query].all.each_with_object({}) { |row, hash| hash[row[:number_of_verifications]] = row[:pact_version_count] }
       end
 
+      # This count has no real meaning and takes too long to do. Hardcode it to -1
       def matrix_count
-        begin
-          PactBroker::Matrix::EveryRow.db.with_statement_timeout(PactBroker.configuration.metrics_sql_statement_timeout) do
-            PactBroker::Matrix::EveryRow.default_scope.count
-          end
-        rescue Sequel::DatabaseError => _ex
-          -1
-        end
+        -1
       end
     end
   end

data/lib/pact_broker/pacticipants/latest_version_for_pacticipant_eager_loader.rb

@@ -0,0 +1,33 @@
+module PactBroker
+  module Pacticipants
+    class LatestVersionForPacticipantEagerLoader
+      def self.call(eo, **_other)
+        populate_associations(eo[:rows])
+      end
+
+      def self.populate_associations(pacticipants)
+        pacticipants.each { | pacticipant | pacticipant.associations[:latest_version] = nil }
+        pacticipant_ids = pacticipants.collect(&:id)
+
+        max_orders = PactBroker::Domain::Version
+                      .where(pacticipant_id: pacticipant_ids)
+                      .select_group(:pacticipant_id)
+                      .select_append { max(order).as(latest_order) }
+
+        max_orders_join = {
+          Sequel[:max_orders][:latest_order] => Sequel[:versions][:order],
+          Sequel[:max_orders][:pacticipant_id] => Sequel[:versions][:pacticipant_id]
+        }
+
+        latest_versions = PactBroker::Domain::Version
+                            .select_all_qualified
+                            .join(max_orders, max_orders_join, { table_alias: :max_orders})
+
+        latest_versions.each do | version |
+          pacticipant = pacticipants.find{ | p | p.id == version.pacticipant_id }
+          pacticipant.associations[:latest_version] = version
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/pacticipants/repository.rb

@@ -1,6 +1,4 @@
-require "sequel"
 require "pact_broker/domain/pacticipant"
-require "pact_broker/repositories/helpers"
 require "pact_broker/error"
 require "pact_broker/repositories/scopes"
 
@@ -9,11 +7,10 @@ module PactBroker
     class Repository
 
       include PactBroker::Repositories
-      include PactBroker::Repositories::Helpers
       include PactBroker::Repositories::Scopes
 
       def find_by_name name
-        pacticipants = PactBroker::Domain::Pacticipant.where(name_like(:name, name)).all
+        pacticipants = PactBroker::Domain::Pacticipant.where(Sequel.name_like(:name, name)).all
         handle_multiple_pacticipants_found(name, pacticipants) if pacticipants.size > 1
         pacticipants.first
       end
@@ -27,7 +24,7 @@ module PactBroker
       # @param [Array<String>] the array of names by which to find the pacticipants
       def find_by_names(names)
         return [] if names.empty?
-        name_likes = names.collect{ | name | name_like(:name, name) }
+        name_likes = names.collect{ | name | Sequel.name_like(:name, name) }
         scope_for(PactBroker::Domain::Pacticipant).where(Sequel.|(*name_likes)).all
       end
 
@@ -35,14 +32,15 @@ module PactBroker
         PactBroker::Domain::Pacticipant.where(id: id).single_record
       end
 
-      def find_all(pagination_options = {})
-        find({}, pagination_options)
+      def find_all(options = {}, pagination_options = {}, eager_load_associations = [])
+        find(options, pagination_options, eager_load_associations)
       end
 
-      def find(options = {}, pagination_options = {})
+      def find(options = {}, pagination_options = {}, eager_load_associations = [])
         query = scope_for(PactBroker::Domain::Pacticipant).select_all_qualified
+        query = query.filter(: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(:labels).eager(:latest_version).all_with_pagination_options(pagination_options)
+        query.order_ignore_case(Sequel[:pacticipants][:name]).eager(*eager_load_associations).all_with_pagination_options(pagination_options)
       end
 
       def find_by_name_or_create name

data/lib/pact_broker/pacticipants/service.rb

@@ -32,8 +32,8 @@ module PactBroker
           } .collect{ | name | pacticipant_repository.find_by_name(name) }
       end
 
-      def self.find_all_pacticipants(pagination_options = {})
-        pacticipant_repository.find_all(pagination_options)
+      def self.find_all_pacticipants(filter_options = {}, pagination_options = {}, eager_load_associations = [])
+        pacticipant_repository.find_all(filter_options, pagination_options, eager_load_associations)
       end
 
       def self.find_pacticipant_by_name(name)

data/lib/pact_broker/pacts/generate_sha.rb

@@ -3,22 +3,27 @@ require "pact_broker/configuration"
 require "pact_broker/pacts/sort_content"
 require "pact_broker/pacts/parse"
 require "pact_broker/pacts/content"
+require "pact_broker/logging"
 
 module PactBroker
   module Pacts
     class GenerateSha
+      include PactBroker::Logging
+
       # @param [String] json_content
-      def self.call json_content, _options = {}
+      def self.call(json_content, _options = {})
         content_for_sha = if PactBroker.configuration.base_equality_only_on_content_that_affects_verification_results
                             extract_verifiable_content_for_sha(json_content)
                           else
                             json_content
                           end
-        Digest::SHA1.hexdigest(content_for_sha)
+        measure_info("Generating SHA1 hexdigest for pact", payload: { length: content_for_sha.length } ){ Digest::SHA1.hexdigest(content_for_sha) }
       end
 
-      def self.extract_verifiable_content_for_sha json_content
-        Content.from_json(json_content).sort.content_that_affects_verification_results.to_json
+      def self.extract_verifiable_content_for_sha(json_content)
+        objects = Content.from_json(json_content)
+        sorted_content = measure_info("Sorting content", payload: { length: json_content.length }){ objects.sort }
+        sorted_content.content_that_affects_verification_results.to_json
       end
     end
   end

data/lib/pact_broker/pacts/latest_pact_publication_id_for_consumer_version.rb

@@ -1,4 +1,4 @@
-require "pact_broker/repositories/helpers"
+require "pact_broker/dataset"
 
 module PactBroker
   module Pacts
@@ -7,9 +7,7 @@ module PactBroker
       unrestrict_primary_key
       plugin :upsert, identifying_columns: [:provider_id, :consumer_version_id]
 
-      dataset_module do
-        include PactBroker::Repositories::Helpers
-      end
+      dataset_module PactBroker::Dataset
     end
   end
 end

data/lib/pact_broker/pacts/metadata.rb

@@ -12,6 +12,7 @@ module PactBroker
         [:consumer_version_selectors, "s"],
         [:tag, "t"],
         [:branch, "b"],
+        [:environment, "e"],
         [:latest, "l"]
       ]
 
@@ -45,6 +46,7 @@ module PactBroker
       # parameters. This is part of ensuring that verification results webhooks
       # go back to the correct consumer version number (eg for git statuses)
       def build_metadata_for_webhook_triggered_by_pact_publication(pact)
+        # Should probably put the branch in here, but I don't think the tags are used for anything
         metadata = {
           "cvn" => pact.consumer_version_number,
           "cvt" => pact.consumer_version_tag_names
@@ -60,13 +62,13 @@ module PactBroker
             "w" => true
           }
         else
-          # TODO support deployed and released
           {
             "s" => verifiable_pact.selectors.collect do | selector |
               {
                 "b" => selector.branch,
                 "t" => selector.tag,
                 "l" => selector.latest,
+                "e" => selector.environment_name,
                 "cv" => selector.consumer_version.id
               }.compact
             end,

data/lib/pact_broker/pacts/pact_params.rb

@@ -20,7 +20,7 @@ module PactBroker
         )
       end
 
-      def self.from_request request, path_info
+      def self.from_request(request, path_info)
         json_content = request.body.to_s
         parsed_content = begin
           parsed = JSON.parse(json_content, PACT_PARSING_OPTIONS)