source_monitor 0.13.0 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba447fce3d49e4605a01154bfbf1a28179ac1833ba1f240add5f1b9adae3ecb3
-  data.tar.gz: 5c90d5148475fd74aa53568df2df60e7143613496df6b985d98acfb5fd84b4c6
+  metadata.gz: d863378a0fb5338b1b1fe89c40c0c0ab9705b3ce60c45889eabf1ed626d27cf1
+  data.tar.gz: d3a56da362430857991b85ab2b24ef10b5e2641dc312ecbe2a302bdca1a8352b
 SHA512:
-  metadata.gz: 4427aaa63507229534a56998290cc6175a18116bba7881c80ce16ef97c9b2dee9b64a4fd37f4d30cac2155805fa19b53258dbb7831f28581ffba56f1a67d814e
-  data.tar.gz: 1b072b1041d24be68a54f2c3a282101c29129fa0e5b34aff15a1ef07f2665ed494760cf37b7827b19cc399b1332cd720696519b2ab46e0c17df0d1a850e28fd0
+  metadata.gz: 885cf285ecc91bf09f2bca2bd9f384cea7f36e1c966a0a74a20d7f87a9df8f69da79dd8363762111c3e206dfe1668ddbefc46cdda71c4e83eaeb138099e74a25
+  data.tar.gz: b38579d624e4e66f5f051ce3aab2e61249fb549310e73e1959cdc0d67aef7fb63ff7c18232563269b2e826c5eb08f2a01bb5cf78f992df90bba3a0649d4d7a21

data/.claude/skills/sm-event-handler/SKILL.md

@@ -98,7 +98,7 @@ Fires after a feed fetch finishes (success or failure).
 | Field | Type | Description |
 |---|---|---|
 | `source` | `SourceMonitor::Source` | The fetched source |
-| `result` | Object | The fetch result |
+| `result` | `SourceMonitor::Fetching::FeedFetcher::Result` | The fetch result |
 | `status` | String | Result status |
 | `occurred_at` | Time | When the event fired |
 

data/.claude/skills/sm-event-handler/reference/events-api.md

@@ -112,7 +112,7 @@ Fired by `Events.after_fetch_completed` after a feed fetch finishes.
 ```ruby
 FetchCompletedEvent = Struct.new(
   :source,      # SourceMonitor::Source - the fetched source
-  :result,      # Object - fetch result
+  :result,      # SourceMonitor::Fetching::FeedFetcher::Result - fetch result
   :status,      # String - result status
   :occurred_at, # Time - when the event fired
   keyword_init: true

data/CHANGELOG.md

@@ -13,7 +13,11 @@ All notable changes to this project are documented below. The format follows [Ke
 
 ## [Unreleased]
 
-- No unreleased changes yet.
+## [0.13.1] - 2026-05-28
+
+### Fixed
+- Preserve the public `after_fetch_completed` payload as `FeedFetcher::Result`; the PR #118 fetch outcome objects remain an internal refactor detail.
+- Keep inactive sources out of sources-index scrape recommendation badges, matching the shared recommendation query used by dashboard and bulk enablement.
 
 ## [0.13.0] - 2026-03-24
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    source_monitor (0.13.0)
+    source_monitor (0.13.1)
       cssbundling-rails (~> 1.4)
       faraday (~> 2.9)
       faraday-follow_redirects (~> 0.4)

data/README.md

@@ -9,8 +9,8 @@ SourceMonitor is a production-ready Rails 8 mountable engine for ingesting, norm
 In your host Rails app:
 
 ```bash
-bundle add source_monitor --version "~> 0.13.0"
-# or add `gem "source_monitor", "~> 0.13.0"` manually, then run:
+bundle add source_monitor --version "~> 0.13.1"
+# or add `gem "source_monitor", "~> 0.13.1"` manually, then run:
 bundle install
 ```
 
@@ -46,7 +46,7 @@ This exposes `bin/source_monitor` (via Bundler binstubs) so you can run the guid
 Before running any SourceMonitor commands inside your host app, add the gem and install dependencies:
 
 ```bash
-bundle add source_monitor --version "~> 0.13.0"
+bundle add source_monitor --version "~> 0.13.1"
 # or edit your Gemfile, then run
 bundle install
 ```

data/app/assets/builds/source_monitor/application.css

@@ -1927,6 +1927,10 @@ video {
   box-shadow: var(--tw-ring-offset-shadow, 0 0 #0000), var(--tw-ring-shadow, 0 0 #0000), var(--tw-shadow);
 }
 
+.fm-admin .outline {
+  outline-style: solid;
+}
+
 .fm-admin .ring-1 {
   --tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);
   --tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color);

data/app/controllers/source_monitor/bulk_scrape_enablements_controller.rb

@@ -33,7 +33,7 @@ module SourceMonitor
 
     def resolve_source_ids
       if params.dig(:bulk_scrape_enablement, :select_all_pages) == "true"
-        Source.scrape_candidates.pluck(:id)
+        SourceMonitor::Analytics::ScrapeRecommendations.new.candidate_ids
       else
         raw_ids = Array(params.dig(:bulk_scrape_enablement, :source_ids))
         raw_ids.map(&:to_i).reject(&:zero?)

data/app/controllers/source_monitor/import_sessions/bulk_configuration.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "source_monitor/import_sessions/entry_normalizer"
+
 module SourceMonitor
   module ImportSessions
     module BulkConfiguration
@@ -33,7 +35,7 @@ module SourceMonitor
         entry = selected_entries_for_identity.first
         return fallback_identity unless entry
 
-        normalized = normalize_entry(entry)
+        normalized = SourceMonitor::ImportSessions::EntryNormalizer.normalize(entry)
         {
           name: normalized[:title].presence || normalized[:feed_url] || fallback_identity[:name],
           feed_url: normalized[:feed_url].presence || fallback_identity[:feed_url],

data/app/controllers/source_monitor/import_sessions_controller.rb

@@ -1,15 +1,10 @@
 # frozen_string_literal: true
 
-require "nokogiri"
-require "uri"
-require "source_monitor/import_sessions/entry_normalizer"
+require "source_monitor/import_sessions/wizard"
 require "source_monitor/sources/params"
 
 module SourceMonitor
   class ImportSessionsController < ApplicationController
-    include SourceMonitor::ImportSessions::OpmlParser
-    include SourceMonitor::ImportSessions::EntryAnnotation
-    include SourceMonitor::ImportSessions::HealthCheckManagement
     include SourceMonitor::ImportSessions::BulkConfiguration
 
     STEP_HANDLERS = {
@@ -86,92 +81,60 @@ module SourceMonitor
     def persist_step!
       return if @import_session.current_step == @current_step
 
-      deactivate_health_checks! if @current_step != "health_check"
+      import_session_wizard.deactivate_health_checks if @current_step != "health_check"
       @import_session.update_column(:current_step, @current_step)
     end
 
     def handle_health_check_step
-      @selected_source_ids = health_check_selection_from_params
-      @import_session.update!(selected_source_ids: @selected_source_ids)
-      if advancing_from_health_check? && @selected_source_ids.blank?
-        @selection_error = "Select at least one source to continue."
-        prepare_health_check_context
+      result = import_session_wizard.handle_health_check
+      @selected_source_ids = result.selected_source_ids
+
+      if result.blocked?
+        @selection_error = result.selection_error
+        apply_health_check_context(result.health_check_context)
         render :show, status: :unprocessable_entity
         return
       end
 
-      @current_step = target_step
-      deactivate_health_checks! if @current_step != "health_check"
-      @import_session.update_column(:current_step, @current_step) if @import_session.current_step != @current_step
-      prepare_health_check_context if @current_step == "health_check"
+      @current_step = result.current_step
+      apply_health_check_context(result.health_check_context) if @current_step == "health_check"
       redirect_to source_monitor.step_import_session_path(@import_session, step: @current_step), allow_other_host: false
     end
 
     def handle_upload_step
-      @upload_errors = validate_upload!
+      result = import_session_wizard.handle_upload
+      @upload_errors = result.errors
       if @upload_errors.any?
         render :show, status: :unprocessable_entity
         return
       end
 
-      parsed_entries = parse_opml_file(params[:opml_file])
-      valid_entries = parsed_entries.select { |entry| entry[:status] == "valid" }
-      if valid_entries.empty?
-        @upload_errors = [ "We couldn't find any valid feeds in that OPML file. Check the file and try again." ]
-        @import_session.update!(opml_file_metadata: build_file_metadata, parsed_sources: parsed_entries, current_step: "upload")
-        render :show, status: :unprocessable_entity
-        return
-      end
-
-      @import_session.update!(
-        opml_file_metadata: build_file_metadata.merge("uploaded_at" => Time.current),
-        parsed_sources: parsed_entries,
-        current_step: target_step
-      )
-
-      @current_step = target_step
-      prepare_preview_context(skip_default: true) if @current_step == "preview"
+      @current_step = result.current_step
+      apply_preview_context(result.preview_context) if @current_step == "preview"
 
       respond_to do |format|
         format.turbo_stream { render :show }
         format.html { redirect_to source_monitor.step_import_session_path(@import_session, step: @current_step) }
       end
-    rescue UploadError => error
-      @upload_errors = [ error.message ]
-      render :show, status: :unprocessable_entity
     end
 
     def handle_preview_step
-      @selected_source_ids = Array(@import_session.selected_source_ids).map(&:to_s)
-
-      if params.dig(:import_session, :select_all).present?
-        @selected_source_ids = selectable_entries.map { |entry| entry[:id] }
-        @import_session.update_column(:selected_source_ids, @selected_source_ids)
-        valid_ids = @selected_source_ids
-      elsif params.dig(:import_session, :select_none).present?
-        @selected_source_ids = []
-        @import_session.update_column(:selected_source_ids, @selected_source_ids)
-        valid_ids = []
-      else
-        @selected_source_ids = build_selection_from_params
-        valid_ids = selectable_entries.index_by { |entry| entry[:id] }.slice(*@selected_source_ids).keys
-        @import_session.update!(selected_source_ids: valid_ids)
-      end
+      result = import_session_wizard.handle_preview
+      @selected_source_ids = result.selected_source_ids
 
-      if advancing_from_preview? && valid_ids.empty?
-        @selection_error = "Select at least one new source to continue."
-        prepare_preview_context(skip_default: true)
+      if result.blocked?
+        @selection_error = result.selection_error
+        apply_preview_context(result.preview_context)
         render :show, status: :unprocessable_entity
         return
       end
 
-      @current_step = target_step
-      @import_session.update_column(:current_step, @current_step) if @import_session.current_step != @current_step
+      @current_step = result.current_step
 
       if @current_step == "health_check"
         prepare_health_check_context
       else
-        prepare_preview_context(skip_default: true)
+        apply_preview_context(result.preview_context)
       end
 
       respond_to do |format|
@@ -200,31 +163,25 @@ module SourceMonitor
     end
 
     def handle_confirm_step
-      @selected_source_ids = Array(@import_session.selected_source_ids).map(&:to_s)
-      @selected_entries = annotated_entries(@selected_source_ids).select { |entry| @selected_source_ids.include?(entry[:id]) }
-      if @selected_entries.empty?
-        @selection_error = "Select at least one source to import."
-        prepare_confirm_context
+      result = import_session_wizard.handle_confirm
+      apply_confirm_context(result)
+
+      if result.blocked?
+        @selection_error = result.selection_error
         render :show, status: :unprocessable_entity
         return
       end
-      history = SourceMonitor::ImportHistory.create!(
-        user_id: @import_session.user_id,
-        bulk_settings: @import_session.bulk_settings
-      )
-      SourceMonitor::ImportOpmlJob.perform_later(@import_session.id, history.id)
-      @import_session.update_column(:current_step, "confirm") if @import_session.current_step != "confirm"
-      message = "Import started for #{@selected_entries.size} sources."
+
       respond_to do |format|
         format.turbo_stream do
           responder = SourceMonitor::TurboStreams::StreamResponder.new
-          responder.toast(message:, level: :success)
+          responder.toast(message: result.message, level: :success)
           responder.redirect(source_monitor.sources_path)
           render turbo_stream: responder.render(view_context)
         end
 
         format.html do
-          redirect_to source_monitor.sources_path, notice: message
+          redirect_to source_monitor.sources_path, notice: result.message
         end
       end
     end
@@ -302,6 +259,95 @@ module SourceMonitor
     end
     # :nocov:
 
+    def import_session_wizard
+      SourceMonitor::ImportSessions::Wizard.new(
+        import_session: @import_session,
+        params: params,
+        current_step: @current_step
+      )
+    end
+
+    def permitted_step(value)
+      step = value.to_s.presence
+      return unless step
+
+      ImportSession::STEP_ORDER.find { |candidate| candidate == step }
+    end
+
+    def target_step
+      permitted_step(import_session_state_params[:next_step]) || @current_step || ImportSession.default_step
+    end
+
+    def session_attributes
+      attrs = import_session_state_params.except(:next_step, :current_step, "next_step", "current_step")
+      attrs[:current_step] = target_step
+      attrs
+    end
+
+    def import_session_state_params
+      @import_session_state_params ||= begin
+        raw = params[:import_session] || params["import_session"] || {}
+        permitted = if raw.respond_to?(:permit)
+          raw.permit(
+            :current_step,
+            :next_step,
+            :select_all,
+            :select_none,
+            parsed_sources: [],
+            selected_source_ids: [],
+            bulk_settings: {},
+            opml_file_metadata: {}
+          )
+        else
+          raw.to_h
+        end
+
+        SourceMonitor::Security::ParameterSanitizer.sanitize(permitted.to_h).with_indifferent_access
+      end
+    end
+
+    def prepare_preview_context(skip_default: false)
+      context = if skip_default
+        import_session_wizard.preview_context
+      else
+        import_session_wizard.preview_context_with_default_selection
+      end
+
+      apply_preview_context(context)
+    end
+
+    def prepare_health_check_context
+      apply_health_check_context(import_session_wizard.health_check_context)
+    end
+
+    def prepare_confirm_context
+      apply_confirm_context(import_session_wizard.confirm_context)
+    end
+
+    def apply_preview_context(context)
+      @filter = context.filter
+      @page = context.page
+      @selected_source_ids = context.selected_source_ids
+      @preview_entries = context.preview_entries
+      @filtered_entries = context.filtered_entries
+      @paginated_entries = context.paginated_entries
+      @has_next_page = context.has_next_page
+      @has_previous_page = context.has_previous_page
+    end
+
+    def apply_health_check_context(context)
+      @selected_source_ids = context.selected_source_ids
+      @health_check_entries = context.health_check_entries
+      @health_check_target_ids = context.health_check_target_ids
+      @health_progress = context.health_progress
+    end
+
+    def apply_confirm_context(context)
+      @selected_source_ids = context.selected_source_ids
+      @selected_entries = context.selected_entries
+      @bulk_settings = context.bulk_settings
+    end
+
     def authorize_import_session!
       return if !SourceMonitor::Security::Authentication.authentication_configured?
 

data/app/controllers/source_monitor/sources_controller.rb

@@ -52,8 +52,9 @@ module SourceMonitor
       @avg_feed_word_counts = word_counts[:feed]
       @avg_scraped_word_counts = word_counts[:scraped]
 
-      @scrape_candidate_ids = compute_scrape_candidate_ids
-      @total_scrape_candidate_count = Source.scrape_candidates.count
+      @scrape_recommendations = SourceMonitor::Analytics::ScrapeRecommendations.new
+      @scrape_candidate_ids = Set.new(@scrape_recommendations.candidate_ids_for(source_ids))
+      @total_scrape_candidate_count = @scrape_recommendations.candidates_count
 
       # Row partial preload requirements (V3): item_activity_rates,
       # avg_feed_word_counts, avg_scraped_word_counts are pre-computed above
@@ -188,23 +189,8 @@ module SourceMonitor
     def expand_scrape_recommendation_filter
       return unless @search_params["scraping_enabled_eq"] == "recommend"
 
-      threshold = SourceMonitor.config.scraping.scrape_recommendation_threshold
       @search_params.delete("scraping_enabled_eq")
-      @search_params["scraping_enabled_eq"] = "false"
-      @search_params["active_eq"] = "true"
-      @search_params["avg_feed_words_lt"] = threshold.to_s
-    end
-
-    def compute_scrape_candidate_ids
-      threshold = SourceMonitor.config.scraping.scrape_recommendation_threshold
-      return Set.new if threshold.nil? || threshold <= 0
-
-      candidate_ids = @sources.select do |source|
-        avg = @avg_feed_word_counts[source.id]
-        avg.present? && avg < threshold && !source.scraping_enabled?
-      end.map(&:id)
-
-      Set.new(candidate_ids)
+      @search_params.merge!(SourceMonitor::Analytics::ScrapeRecommendations.new.filter_params)
     end
 
     def enqueue_unscraped_items(source)

data/app/models/source_monitor/source.rb

@@ -66,7 +66,7 @@ module SourceMonitor
       end
 
       def scrape_candidates(threshold: SourceMonitor.config.scraping.scrape_recommendation_threshold)
-        SourceMonitor::Queries::ScrapeCandidatesQuery.new(threshold:).call
+        SourceMonitor::Analytics::ScrapeRecommendations.new(threshold:).relation
       end
 
       # Bulk-enable scraping for sources that don't already have it enabled.

data/docs/setup.md

@@ -18,8 +18,8 @@ This guide consolidates the new guided installer, verification commands, and rol
 Run these commands inside your host Rails application before invoking the guided workflow:
 
 ```bash
-bundle add source_monitor --version "~> 0.13.0"
-# or add gem "source_monitor", "~> 0.13.0" to Gemfile manually
+bundle add source_monitor --version "~> 0.13.1"
+# or add gem "source_monitor", "~> 0.13.1" to Gemfile manually
 bundle install
 ```
 

data/docs/upgrade.md

@@ -46,6 +46,20 @@ If a removed option raises an error (`SourceMonitor::DeprecatedOptionError`), yo
 
 ## Version-Specific Notes
 
+### Upgrading to 0.13.1
+
+**What changed:**
+- **Compatibility:** `after_fetch_completed` callbacks continue to receive `FeedFetcher::Result`; the fetch outcome extraction remains internal.
+- **Scrape recommendations:** Inactive sources stay excluded from source-index recommendation badges, matching dashboard and bulk enablement behavior.
+
+**Upgrade steps:**
+```bash
+bundle update source_monitor
+bin/rails source_monitor:upgrade
+```
+
+No migrations, configuration changes, or breaking changes required.
+
 ### Upgrading to 0.13.0
 
 **What changed:**

data/lib/source_monitor/analytics/scrape_recommendations.rb

@@ -7,18 +7,37 @@ module SourceMonitor
         @threshold = threshold.to_i
       end
 
+      def relation
+        @relation ||= SourceMonitor::Queries::ScrapeCandidatesQuery.new(threshold: threshold).call
+      end
+
       def candidates_count
-        @candidates_count ||= Source.scrape_candidates(threshold: @threshold).count
+        @candidates_count ||= relation.count
       end
 
       def candidate_ids
-        @candidate_ids ||= Source.scrape_candidates(threshold: @threshold).pluck(:id)
+        @candidate_ids ||= relation.pluck(:id)
+      end
+
+      def candidate_ids_for(source_ids)
+        ids = Array(source_ids).map { |source_id| source_id.respond_to?(:id) ? source_id.id : source_id }.compact
+        return [] if ids.empty?
+
+        relation.where(id: ids).pluck(:id)
       end
 
       def candidate?(source_id)
         candidate_ids.include?(source_id)
       end
 
+      def filter_params
+        {
+          "scraping_enabled_eq" => "false",
+          "active_eq" => "true",
+          "avg_feed_words_lt" => threshold.to_s
+        }
+      end
+
       private
 
       attr_reader :threshold

data/lib/source_monitor/fetching/feed_fetcher/failure_outcome.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module SourceMonitor
+  module Fetching
+    class FeedFetcher
+      class FailureOutcome
+        def initialize(error:)
+          @error = error
+        end
+
+        attr_reader :error, :retry_decision
+
+        def apply(source_updater:, started_at:, instrumentation_payload:)
+          duration_ms = source_updater.elapsed_ms(started_at)
+          @retry_decision = update_source(source_updater, duration_ms)
+          create_fetch_log(source_updater, duration_ms, started_at)
+          apply_instrumentation(instrumentation_payload)
+          result
+        end
+
+        def status
+          :failed
+        end
+
+        def response
+          error.response
+        end
+
+        def body
+          response&.body
+        end
+
+        def feed
+          nil
+        end
+
+        def item_processing
+          @item_processing ||= EntryProcessingResult.empty
+        end
+
+        private
+
+        def update_source(source_updater, duration_ms)
+          source_updater.update_source_for_failure(error, duration_ms)
+        end
+
+        def create_fetch_log(source_updater, duration_ms, started_at)
+          source_updater.create_fetch_log(
+            response: response,
+            duration_ms: duration_ms,
+            started_at: started_at,
+            success: false,
+            error: error,
+            body: body
+          )
+        end
+
+        def apply_instrumentation(instrumentation_payload)
+          instrumentation_payload[:success] = false
+          instrumentation_payload[:status] = status
+          instrumentation_payload[:error_class] = error.class.name
+          instrumentation_payload[:error_message] = error.message
+          instrumentation_payload[:http_status] = error.http_status if error.http_status
+          instrumentation_payload[:error_code] = error.code if error.respond_to?(:code)
+          instrumentation_payload[:items_created] = 0
+          instrumentation_payload[:items_updated] = 0
+          instrumentation_payload[:items_failed] = 0
+          instrumentation_payload[:retry_attempt] = retry_decision&.next_attempt ? retry_decision.next_attempt : 0
+        end
+
+        def result
+          Result.new(
+            status: status,
+            response: response,
+            body: body,
+            error: error,
+            retry_decision: retry_decision,
+            item_processing: item_processing,
+            outcome: self
+          )
+        end
+      end
+    end
+  end
+end

data/lib/source_monitor/fetching/feed_fetcher/success_outcome.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module SourceMonitor
+  module Fetching
+    class FeedFetcher
+      class SuccessOutcome
+        def initialize(response:, body:, feed:, item_processing:, feed_signature:, content_changed:, entries_digest:)
+          @response = response
+          @body = body
+          @feed = feed
+          @item_processing = item_processing
+          @feed_signature = feed_signature
+          @content_changed = content_changed
+          @entries_digest = entries_digest
+        end
+
+        attr_reader :response, :body, :feed, :item_processing, :feed_signature, :content_changed, :entries_digest
+
+        def apply(source_updater:, started_at:, instrumentation_payload:)
+          duration_ms = source_updater.elapsed_ms(started_at)
+          update_source(source_updater, duration_ms)
+          create_fetch_log(source_updater, duration_ms, started_at)
+          apply_instrumentation(instrumentation_payload)
+          result
+        end
+
+        def status
+          :fetched
+        end
+
+        def error
+          nil
+        end
+
+        def retry_decision
+          nil
+        end
+
+        def result
+          Result.new(status: status, feed: feed, response: response, body: body, item_processing: item_processing, outcome: self)
+        end
+
+        private
+
+        def update_source(source_updater, duration_ms)
+          source_updater.update_source_for_success(
+            response,
+            duration_ms,
+            feed,
+            feed_signature,
+            content_changed: content_changed,
+            entries_digest: entries_digest
+          )
+        end
+
+        def create_fetch_log(source_updater, duration_ms, started_at)
+          source_updater.create_fetch_log(
+            response: response,
+            duration_ms: duration_ms,
+            started_at: started_at,
+            feed: feed,
+            success: true,
+            body: body,
+            feed_signature: feed_signature,
+            items_created: item_processing.created,
+            items_updated: item_processing.updated,
+            items_failed: item_processing.failed,
+            item_errors: item_processing.errors
+          )
+        end
+
+        def apply_instrumentation(instrumentation_payload)
+          instrumentation_payload[:success] = true
+          instrumentation_payload[:status] = :fetched
+          instrumentation_payload[:http_status] = response.status
+          instrumentation_payload[:parser] = feed.class.name if feed
+          instrumentation_payload[:items_created] = item_processing.created
+          instrumentation_payload[:items_updated] = item_processing.updated
+          instrumentation_payload[:items_failed] = item_processing.failed
+          instrumentation_payload[:retry_attempt] = 0
+        end
+      end
+    end
+  end
+end