inferno_core 1.4.1 → 1.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d24d5fad7804605708193855dec5e392045301a3a02ed94136d02f659a5f45e
-  data.tar.gz: df3d42baee167e540a41f3d4a5bc53afd307751c695b4202e1886c910468736c
+  metadata.gz: 044cfcbc6d3920cfba55d0d63fbf0fb3a1440f4f42a2e45d763beb78f280306a
+  data.tar.gz: 243c006acc71fddd3eb165a2c400a1eab4e515f8c3f4915b27cd60fc8e41e734
 SHA512:
-  metadata.gz: 5286cc2c1c41c90a48e81806330d366eb87157b9a8f7d6f183db7919486925af880707d0728b504b42356a701c206b4b4c7c0eed07762ea4cf4d5605b68934fe
-  data.tar.gz: 4e722dffacb5ffbff4fae5827718cac7d77ad331f4675c14db8a873766cb9a71cb690e0e3c1dbe16b7e9d6d5a0ba3e3b55ee2f247d07cc9133503870a6377c0b
+  metadata.gz: a1c934c0c6bb863a66e34b2830807ee274f443323d7c74c10023bf078329abf2bc70d9125f481b388c3e9ac61a647c81a8f6ee6f7c156078a9dc4fc31adcb671
+  data.tar.gz: 6a54d11609e88fadd4c4750966e66a1df705ab1a1c79b8c8c0b99f5d3a19467496c46db740dfb2937610c9c78e8a7bf14db7fe8112c7c8399bb43a16bdcd6937

data/lib/inferno/apps/cli/execute_script.rb

@@ -137,8 +137,8 @@ module Inferno
       )
 
       ExecutionStatus = Struct.new(
-        :done, :failed, :timed_out, :current_session, :current_timeout, :last_log_time,
-        :cross_session_status, :last_step_signatures
+        :done, :failed, :timed_out, :cancel_pending, :current_session, :current_timeout, :last_log_time,
+        :poll_start_time, :cross_session_status, :last_step_signatures
       )
 
       attr_accessor :yaml_file, :options, :execution_status
@@ -152,8 +152,10 @@ module Inferno
           done: false,
           failed: false,
           timed_out: false,
+          cancel_pending: false,
           current_session: sessions.first,
           current_timeout: options[:default_poll_timeout],
+          poll_start_time: nil,
           cross_session_status: {},
           last_step_signatures: {}
         )
@@ -234,13 +236,15 @@ module Inferno
         creator = Session::CreateSession.new(suite, session_create_options(session_config))
         session_details = creator.create_session
         key = session_config['name'] || suite
-        warn "Session created: #{session_details['id']}"
-        ScriptSession.new(
+        script_session = ScriptSession.new(
           key: key,
           suite_id: session_details['test_suite_id'],
           session_id: session_details['id'],
           short_id_map: extract_short_ids_from_session_details(session_details)
         )
+        warn "Session created: #{session_details['id']}"
+        warn "  Available at #{session_display_url(script_session)}"
+        script_session
       end
 
       def session_create_options(session_config)
@@ -413,6 +417,7 @@ module Inferno
         warn ''
         warn "Polling session: #{session.key} (#{session.session_id}) timeout=#{timeout}s"
         deadline = Time.now + timeout
+        execution_status.poll_start_time = Time.now
         execution_status.last_log_time = Time.now - LOG_INTERVAL_SECONDS
 
         loop do
@@ -442,6 +447,10 @@ module Inferno
 
       # Returns a step hash to act on, or nil to keep polling.
       def handle_actionable_status(status, session, timeout)
+        # A cancelled run's done status is indistinguishable from the
+        # runnable completing normally, so don't match steps against it.
+        return handle_cancel_completion(status, session, timeout) if execution_status.cancel_pending
+
         matched_step = match_step(status, session.key)
 
         if matched_step
@@ -463,10 +472,16 @@ module Inferno
         last_completed = format_last_completed(last_completed_from_status(status), session.key)
         warn "UNHANDLED WAIT - Canceling: session=#{session.key} last_completed=#{last_completed}"
         execution_status.failed = true
+        execution_status.cancel_pending = true
         attempt_cancel(session.session_id, status)
         nil
       end
 
+      def handle_cancel_completion(status, session, timeout)
+        warn "Cancellation complete: session=#{session.key} status=#{status['status']}"
+        { command: nil, timeout: timeout, next_poll_session: nil }
+      end
+
       def handle_unmatched_status(status, session, timeout)
         run_status = status['status']
         last_completed = format_last_completed(last_completed_from_status(status), session.key)
@@ -485,6 +500,7 @@ module Inferno
           execution_status.failed = true
           if run_status == 'waiting'
             warn "Loop detected - Canceling: session=#{session.key} last_completed=#{last_completed}"
+            execution_status.cancel_pending = true
             attempt_cancel(session.session_id, status)
             return nil
           else
@@ -504,10 +520,16 @@ module Inferno
         last_completed = last_completed_from_status(status)
         poll_status_last_test =
           last_completed.present? ? " - last test: #{format_last_completed(last_completed, session_key)}" : ''
-        warn "  [#{session_key}] #{status['status']}#{poll_status_last_test}"
+        elapsed = (Time.now - execution_status.poll_start_time).round
+        warn "  [#{session_key}] #{status['status']} (#{test_progress(status, elapsed)})" \
+             "#{poll_status_last_test}"
         execution_status.last_log_time = Time.now
       end
 
+      def test_progress(status, elapsed)
+        "completed #{status['completed_test_count']}/#{status['test_count']} tests in #{elapsed}s"
+      end
+
       def fetch_session_status(session_id)
         Session::SessionStatus.new(session_id, options).status_for_session
       end

data/lib/inferno/apps/cli/requirements_coverage_checker.rb

@@ -119,7 +119,7 @@ module Inferno
             suite_runnables.select { |runnable| runnable.verifies_requirements.include? requirement_id }
 
           runnables_for_requirement.map do |runnable|
-            [requirement_id, runnable.short_id, runnable.id]
+            [requirement_id, runnable < Inferno::Entities::TestSuite ? 'suite' : runnable.short_id, runnable.id]
           end
         end
       end

data/lib/inferno/apps/cli/session/session_compare.rb

@@ -1,5 +1,6 @@
 require 'csv'
 require 'cgi'
+require 'uri'
 require_relative 'session_details'
 require_relative 'session_results'
 
@@ -82,16 +83,39 @@ module Inferno
         end
 
         def save_actual_results_to_file
-          actual_results_file_name = "#{output_file_prefix}actual_results_#{results_timestamp}.json"
-          File.write(File.join(output_directory, actual_results_file_name), session_results.to_json)
+          actual_results_file_name = "#{output_file_prefix}actual_results_#{results_timestamp}#{host_suffix}.json"
+          File.write(File.join(output_directory, actual_results_file_name), JSON.pretty_generate(session_results))
         end
 
         def save_comparison_csv_to_file
-          compared_csv_file_name = "#{output_file_prefix}compared_results_#{results_timestamp}.csv"
+          compared_csv_file_name = "#{output_file_prefix}compared_results_#{results_timestamp}#{host_suffix}.csv"
           File.write(File.join(output_directory, compared_csv_file_name),
                      compared_results_as_csv)
         end
 
+        # Filesystem-safe "_<host>" (plus non-default port, if any) suffix derived from
+        # the --inferno-base-url (-I) option, so output filenames can be disambiguated
+        # by target server. Empty when -I was not passed or the URL has no host.
+        def host_suffix
+          inferno_host_slug ? "_#{inferno_host_slug}" : ''
+        end
+
+        def inferno_host_slug
+          return nil unless options[:inferno_base_url].present?
+
+          uri = begin
+            URI.parse(options[:inferno_base_url])
+          rescue URI::InvalidURIError
+            nil
+          end
+          host = uri&.host
+          return nil unless host
+
+          slug = host.dup
+          slug << "_#{uri.port}" if uri.port && uri.port != uri.default_port
+          slug.gsub(/[^a-zA-Z0-9.-]/, '_')
+        end
+
         def display_compared_results
           output = {
             matched: results_match?,

data/lib/inferno/apps/cli/session/session_status.rb

@@ -27,7 +27,10 @@ module Inferno
 
           if session_status['id'].present?
             run_id = session_status['id']
-            last_test_executed = last_test_executed(run_id)
+            test_results = run_results(run_id).select { |result| result['test_id'].present? }
+            session_status['completed_test_count'] = test_results.size
+
+            last_test_executed = last_test_executed(test_results, session_status['status'])
             if last_test_executed.present?
               session_status['last_test_executed'] = last_test_executed['test_id']
               if session_status['status'] == 'waiting'
@@ -53,9 +56,22 @@ module Inferno
           }
         end
 
-        def last_test_executed(run_id)
-          results = run_results(run_id)
-          results.sort_by { |r| r['updated_at'] }.reverse.find { |result| result['test_id'].present? }
+        # Serialized updated_at values can collide when results are written in
+        # quick succession, so when the run is waiting, identify the waiting
+        # test by its 'wait' result rather than by timestamp order alone.
+        def last_test_executed(test_results, run_status)
+          if run_status == 'waiting'
+            wait_results = test_results.select { |result| result['result'] == 'wait' }
+            test_results = wait_results if wait_results.any?
+          end
+
+          most_recent_result(test_results)
+        end
+
+        # updated_at ties are broken by array position (later results win)
+        # since the API returns results in insertion order.
+        def most_recent_result(results)
+          results.each_with_index.max_by { |result, index| [result['updated_at'].to_s, index] }&.first
         end
 
         def run_results(run_id)

data/lib/inferno/apps/web/controllers/test_runs/create.rb

@@ -37,7 +37,14 @@ module Inferno
 
             persist_inputs(session_data_repo, req.params, test_run.runnable)
 
-            Jobs.perform(Jobs::ExecuteTestRun, test_run.id)
+            Jobs.perform(
+              Jobs::ExecuteTestRun,
+              test_run.id,
+              tags: [
+                "session:#{test_session.id}",
+                "run:#{test_run.test_suite_id || test_run.test_group_id || test_run.test_id}"
+              ]
+            )
           rescue Sequel::ValidationFailed, Sequel::ForeignKeyConstraintViolation,
                  Inferno::Exceptions::RequiredInputsNotFound,
                  Inferno::Exceptions::NotUserRunnableException => e

data/lib/inferno/apps/web/controllers/test_runs/destroy.rb

@@ -22,7 +22,16 @@ module Inferno
             if test_run_is_waiting
               waiting_result = results_repo.find_waiting_result(test_run_id: test_run.id)
               results_repo.update_result(waiting_result.id, 'cancel', 'Test cancelled by user')
-              Jobs.perform(Jobs::ResumeTestRun, test_run.id)
+              Jobs.perform(
+                Jobs::ResumeTestRun,
+                test_run.id,
+                tags: [
+                  'source:delete',
+                  "session:#{test_run.test_session_id}",
+                  "run:#{test_run.test_suite_id || test_run.test_group_id || test_run.test_id}",
+                  "test:#{waiting_result.test_id}"
+                ]
+              )
             end
 
             res.status = 204

data/lib/inferno/config/boot/db.rb

@@ -1,6 +1,46 @@
 require 'sequel'
 require 'erb'
 
+module Inferno
+  module Config
+    module Boot
+      # Extracted from the :db provider below so the sqlite-only branching can
+      # be unit tested with plain config hashes/doubles, instead of requiring
+      # a real postgres connection (which this project has no infrastructure
+      # for) just to exercise the non-sqlite path.
+      module Db
+        module_function
+
+        # The web and worker processes each hold their own pool of connections to the
+        # same sqlite file, so writes from one process can easily collide with reads
+        # or writes from another. WAL mode lets readers proceed without blocking on a
+        # concurrent writer, and a longer busy_timeout gives a blocked writer more
+        # room to wait its turn instead of immediately raising SQLITE_BUSY.
+        #
+        # If you change this, run `bundle exec rake db:check_concurrency` to verify
+        # SQLITE_BUSY is still avoided under concurrent test-run writes and status
+        # polling (see lib/inferno/utils/db_concurrency_check.rb for why that's a
+        # rake task and not a spec).
+        def configure_sqlite_pragmas!(config)
+          return config unless config['adapter'] == 'sqlite'
+
+          connect_sqls = ["PRAGMA busy_timeout = #{ENV.fetch('DB_BUSY_TIMEOUT_MS', '15000')}"]
+          connect_sqls << 'PRAGMA journal_mode = WAL' unless config['database'] == ':memory:'
+          config['connect_sqls'] = connect_sqls
+          config
+        end
+
+        def log_sqlite_journal_mode(config, connection, logger)
+          return unless config['adapter'] == 'sqlite'
+
+          actual_journal_mode = connection.fetch('PRAGMA journal_mode').first[:journal_mode]
+          logger.info("sqlite journal_mode: #{actual_journal_mode}")
+        end
+      end
+    end
+  end
+end
+
 Inferno::Application.register_provider(:db) do
   prepare do
     target_container.start :logging
@@ -13,6 +53,9 @@ Inferno::Application.register_provider(:db) do
     config_contents = ERB.new(File.read(config_path)).result
     config = YAML.safe_load(config_contents)[ENV.fetch('APP_ENV', nil)]
       .merge(logger: Inferno::Application['logger'])
+
+    Inferno::Config::Boot::Db.configure_sqlite_pragmas!(config)
+
     connection_attempts_remaining = ENV.fetch('MAX_DB_CONNECTION_ATTEMPTS', '10').to_i
     connection_retry_delay = ENV.fetch('DB_CONNECTION_RETRY_DELAY', '5').to_i
     connection = nil
@@ -31,6 +74,8 @@ Inferno::Application.register_provider(:db) do
     end
     connection.sql_log_level = :debug
 
+    Inferno::Config::Boot::Db.log_sqlite_journal_mode(config, connection, Inferno::Application['logger'])
+
     register('db.config', config)
     register('db.connection', connection)
   end

data/lib/inferno/config/boot/executor.rb

@@ -7,6 +7,10 @@ Inferno::Application.register_provider(:executor) do
 
     Blueprinter.configure do |config|
       config.generator = Oj
+      # Oj >= 3.17 no longer honors ActiveSupport's Time#to_json, which
+      # dropped sub-second precision from serialized timestamps. Clients
+      # order results by these strings, so keep millisecond precision.
+      config.datetime_format = '%FT%T.%L%:z'
     end
 
     target_container.start :suites

data/lib/inferno/config/boot/web.rb

@@ -5,6 +5,10 @@ Inferno::Application.register_provider(:web) do |_app|
 
     Blueprinter.configure do |config|
       config.generator = Oj
+      # Oj >= 3.17 no longer honors ActiveSupport's Time#to_json, which
+      # dropped sub-second precision from serialized timestamps. Clients
+      # order results by these strings, so keep millisecond precision.
+      config.datetime_format = '%FT%T.%L%:z'
     end
 
     # Workers aren't connected to a web server, so they shouldn't be hosting

data/lib/inferno/dsl/fhir_resource_navigation.rb

@@ -42,8 +42,13 @@ module Inferno
       # @param given_element [FHIR::Model, Array<FHIR::Model>]
       # @param path [String]
       # @param include_dar [Boolean]
+      # @param recursive_segments [Array<String>] names of path segments that are
+      #   self-referential (eg. `item` in Questionnaire.item.item, via a FHIR
+      #   `contentReference`). When a segment matches, the search also continues
+      #   into deeper repeats of that segment (item.item.item...) if the value
+      #   isn't found at the literal path depth.
       # @return a single matching value (which can include `false`) or `nil` if not found
-      def find_a_value_at(given_element, path, include_dar: false, &block)
+      def find_a_value_at(given_element, path, include_dar: false, recursive_segments: [], &block)
         return nil if given_element.nil?
 
         elements = Array.wrap(given_element)
@@ -56,8 +61,13 @@ module Inferno
         remaining_path = path_segments.join('.')
         elements.each do |element|
           child = get_next_value(element, segment)
-          element_found = find_a_value_at(child, remaining_path, include_dar:, &block)
+          element_found = find_a_value_at(child, remaining_path, include_dar:, recursive_segments:, &block)
           return element_found if value_not_empty?(element_found)
+
+          next unless recursive_segments.include?(segment)
+
+          nested_found = find_a_value_at(child, path, include_dar:, recursive_segments:, &block)
+          return nested_found if value_not_empty?(nested_found)
         end
 
         nil

data/lib/inferno/dsl/fhir_resource_validation.rb

@@ -26,6 +26,7 @@ module Inferno
     #       allowExampleUrls true
     #       txServer nil
     #     end
+    #     expansion_parameters 'path/to/expansion_parameters.json'
     #   end
     module FHIRResourceValidation
       def self.included(klass)
@@ -118,6 +119,99 @@ module Inferno
 
         alias cli_context validation_context
 
+        # Environment variable containing the default expansion parameters.
+        # Used by {#expansion_parameters} when no value has been set
+        # explicitly. May contain either the raw JSON content of a FHIR
+        # Parameters resource (if it starts with `{`) or a path to a file
+        # containing one.
+        EXPANSION_PARAMETERS_ENV_VAR = 'FHIR_RESOURCE_VALIDATOR_EXPANSION_PARAMETERS'.freeze
+
+        # Set the expansion parameters to be sent with each validation
+        # request. This configures how the validator's terminology engine
+        # expands value sets during validation (e.g. designation
+        # preferences, forcing the use of the latest terminology versions,
+        # etc.). The content is sent inline with every validation request
+        # made by this validator, since the validator does not have access
+        # to Inferno's filesystem.
+        #
+        # Accepts either a Hash containing the contents of a FHIR Parameters
+        # resource, or a String path to a file (JSON or XML) containing one.
+        # The file is read once, the first time it's needed.
+        #
+        # If never set explicitly, this falls back to the
+        # `FHIR_RESOURCE_VALIDATOR_EXPANSION_PARAMETERS` environment
+        # variable, if present. This allows a shared set of expansion
+        # parameters to be configured once for every test kit that uses a
+        # given validator instance, while still letting individual test
+        # kits opt out or override it by calling this method themselves.
+        # The environment variable's content is treated as raw JSON if it
+        # starts with `{`, and otherwise as a file path.
+        #
+        # @example
+        #   # Passing a Hash
+        #   fhir_resource_validator do
+        #     url 'http://example.com/validator'
+        #     expansion_parameters({
+        #       resourceType: 'Parameters',
+        #       parameter: [{ name: 'excludeNested', valueBoolean: true }]
+        #     })
+        #   end
+        #
+        # @example
+        #   # Passing a file path
+        #   fhir_resource_validator do
+        #     url 'http://example.com/validator'
+        #     expansion_parameters 'path/to/expansion_parameters.json'
+        #   end
+        #
+        # @param value [Hash, String, nil] contents of a Parameters resource
+        #   as a Hash, or a path to a file (JSON or XML) containing one
+        def expansion_parameters(value = nil)
+          if value
+            @expansion_parameters = build_expansion_parameters(value)
+          elsif !@expansion_parameters_resolved
+            env_value = ENV.fetch(EXPANSION_PARAMETERS_ENV_VAR, nil)
+            @expansion_parameters = build_expansion_parameters_from_env(env_value) if env_value
+          end
+          @expansion_parameters_resolved = true
+
+          @expansion_parameters
+        end
+
+        # @private
+        # Determines whether the environment variable's content is raw JSON
+        # or a file path based on its first non-whitespace character.
+        def build_expansion_parameters_from_env(env_value)
+          if env_value.lstrip.start_with?('{')
+            build_expansion_parameters_from_json_content(env_value)
+          else
+            build_expansion_parameters(env_value)
+          end
+        end
+
+        # @private
+        def build_expansion_parameters(value)
+          case value
+          when Hash
+            build_expansion_parameters_from_json_content(value.to_json)
+          else
+            {
+              fileName: File.basename(value),
+              fileContent: File.read(value),
+              fileType: nil
+            }
+          end
+        end
+
+        # @private
+        def build_expansion_parameters_from_json_content(json_content)
+          {
+            fileName: 'expansion_parameters.json',
+            fileContent: json_content,
+            fileType: nil
+          }
+        end
+
         # @private
         # Used internally by perform_additional_validation
         def additional_validations
@@ -622,6 +716,8 @@ module Inferno
             ],
             sessionId: @session_id
           }
+          wrapped_resource[:expansionParameters] = expansion_parameters if expansion_parameters
+
           wrapped_resource.to_json
         end
       end

data/lib/inferno/dsl/input_output_handling.rb

@@ -193,14 +193,16 @@ module Inferno
               inputs[input.name.to_sym] = Entities::Input.new(**input.to_hash)
             end
 
+        # children_available_inputs walks the entire subtree, so it is computed once here
+        # rather than once per input. merge_with_child only mutates its receiver, so the
+        # child definitions are safe to reuse for the merge below.
+        child_inputs = children_available_inputs(selected_suite_options)
+
         available_inputs.each do |input, current_definition|
-          child_definition = children_available_inputs(selected_suite_options)[input]
-          current_definition.merge_with_child(child_definition)
+          current_definition.merge_with_child(child_inputs[input])
         end
 
-        available_inputs = children_available_inputs(selected_suite_options).merge(available_inputs)
-
-        order_available_inputs(available_inputs)
+        order_available_inputs(child_inputs.merge(available_inputs))
       end
     end
   end

data/lib/inferno/dsl/must_support_assessment.rb

@@ -15,10 +15,14 @@ module Inferno
       # @param resources [Array<FHIR::Resource>]
       # @param profile_url [String]
       # @param validator_name [Symbol] Name of the FHIR Validator that references the IG the profile is in
-      # @param metadata [Hash] MustSupport Metadata (optional),
-      #        if provided the check will use this instead of re-generating metadata from the profile
+      # @param metadata [Inferno::DSL::ProfileMetadata, #must_supports] MustSupport Metadata (optional),
+      #        if provided the check will use this instead of re-generating metadata from the profile.
+      #        Must respond to `#must_supports`, returning a Hash with `:elements`, `:extensions`, and
+      #        `:slices` keys (and optionally `:choices` and `:recursive_elements`) -- the shape produced by
+      #        {MustSupportMetadataExtractor#must_supports}. {Inferno::DSL::ProfileMetadata} is a base class
+      #        test kits can subclass to build these objects, eg from generated YAML, instead of hand-rolling one.
       # @param requirement_extension [String] Extension URL that implies "required" as an alternative to the MS flag
-      # @yield [Metadata] Customize the metadata before running the test
+      # @yield [MustSupportMetadataExtractor] Customize the metadata before running the test
       # @return [Array<String>] List of missing elements
       def missing_must_support_elements(resources, profile_url, validator_name: :default, metadata: nil,
                                         requirement_extension: nil, &)
@@ -199,6 +203,12 @@ module Inferno
           metadata.must_supports[:extensions]
         end
 
+        # Names of path segments that are self-referential (eg 'item' in Questionnaire.item.item)
+        # and so should be searched at any depth of nesting, not just the literal depth of a path.
+        def recursive_element_segments
+          Array.wrap(metadata.must_supports[:recursive_elements])
+        end
+
         def missing_extensions(resources = [])
           @missing_extensions ||=
             must_support_extensions.select do |extension_definition|
@@ -212,7 +222,7 @@ module Inferno
                     normalized_extension_url(extension.url) == expected_url
                   end
                 else
-                  extension = find_a_value_at(resource, path) do |el|
+                  extension = find_a_value_at(resource, path, recursive_segments: recursive_element_segments) do |el|
                     normalized_extension_url(el.url) == expected_url
                   end
 
@@ -243,9 +253,10 @@ module Inferno
           ms_extension_urls = must_support_extensions.select { |ex| ex[:path] == "#{raw_path}.extension" }
             .map { |ex| ex[:url] }
 
-          value_found = find_a_value_at(resource, path) do |potential_value|
-            matching_without_extensions?(potential_value, ms_extension_urls, element_definition[:fixed_value])
-          end
+          value_found =
+            find_a_value_at(resource, path, recursive_segments: recursive_element_segments) do |potential_value|
+              matching_without_extensions?(potential_value, ms_extension_urls, element_definition[:fixed_value])
+            end
 
           # Note that false.present? => false, which is why we need to add this extra check
           value_found.present? || value_found == false
@@ -369,7 +380,7 @@ module Inferno
           # TODO: there is a lot of similarity
           # between this and FHIRResourceNavigation.matching_slice?
           # Can these be combined?
-          find_a_value_at(resource, path) do |element|
+          find_a_value_at(resource, path, recursive_segments: recursive_element_segments) do |element|
             case discriminator[:type]
             when 'patternCodeableConcept'
               find_pattern_codeable_concept_slice(element, discriminator)

data/lib/inferno/dsl/must_support_metadata_extractor.rb

@@ -24,16 +24,49 @@ module Inferno
         self.requirement_extension_url = requirement_extension_url
       end
 
+      # @return [String] the canonical URL of the profile
+      def profile_url
+        profile.url
+      end
+
+      # @return [String] the human-readable name of the profile, eg for display purposes.
+      #   Collapses any runs of repeated whitespace, since profile titles occasionally have them.
+      def profile_name
+        profile.title&.squeeze(' ')
+      end
+
+      # @return [String] the version of the profile itself (distinct from the IG's own version)
+      def profile_version
+        profile.version
+      end
+
       # Retrieval method for the must support metadata
       # @return [Hash]
       def must_supports
         @must_supports ||= {
           extensions: must_support_extensions,
           slices: must_support_slices,
-          elements: must_support_elements
+          elements: must_support_elements,
+          recursive_elements: recursive_element_segments
         }
       end
 
+      # Names of path segments that are self-referential, ie, they may repeat at
+      # arbitrary depth. FHIR marks this with a `contentReference` back to an
+      # ancestor element instead of re-declaring the element's children, eg,
+      # Questionnaire.item.item has a contentReference of "#Questionnaire.item".
+      # A MustSupport flag on an element under such a segment (eg Questionnaire.item.text)
+      # should be considered met if it's populated at any depth of nesting
+      # (item.text, item.item.text, item.item.item.text, ...), not just the literal depth
+      # at which the flag is declared. NOTE: does not currently handle sliced recursive elements.
+      # @return [Array<String>]
+      def recursive_element_segments
+        profile_elements
+          .select { |element| element.contentReference.present? }
+          .map { |element| element.id.split('.').last }
+          .uniq
+      end
+
       def by_requirement_extension_only?(element)
         requirement_extension_url && !element.mustSupport &&
           element.extension.any? do |extension|
@@ -53,6 +86,7 @@ module Inferno
         must_support_extension_elements.map do |element|
           {
             id: element.id,
+            slice_name: extension_slice_name(element.id),
             path: element.path.gsub("#{resource}.", ''),
             url: canonical_url_without_version(element.type.first.profile.first),
             modifier_extension: element.path.end_with?('modifierExtension')
@@ -62,6 +96,15 @@ module Inferno
         end
       end
 
+      # The name of the deepest slice in a FHIR ElementDefinition id, eg "us-core-race" for
+      # "Patient.extension:us-core-race" or "ombCategory" for
+      # "Patient.extension:us-core-race.extension:ombCategory".
+      # @param element_id [String]
+      # @return [String, nil]
+      def extension_slice_name(element_id)
+        element_id.split('.').reverse.find { |segment| segment.include?(':') }&.split(':', 2)&.last
+      end
+
       def canonical_url_without_version(url)
         url&.split('|')&.first
       end