source_monitor 0.13.0 → 0.14.0

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

data/lib/source_monitor/fetching/feed_fetcher.rb

@@ -9,11 +9,13 @@ require "source_monitor/items/item_creator"
 require "source_monitor/fetching/feed_fetcher/adaptive_interval"
 require "source_monitor/fetching/feed_fetcher/source_updater"
 require "source_monitor/fetching/feed_fetcher/entry_processor"
+require "source_monitor/fetching/feed_fetcher/success_outcome"
+require "source_monitor/fetching/feed_fetcher/failure_outcome"
 
 module SourceMonitor
   module Fetching
     class FeedFetcher
-      Result = Struct.new(:status, :feed, :response, :body, :error, :item_processing, :retry_decision, keyword_init: true)
+      Result = Struct.new(:status, :feed, :response, :body, :error, :item_processing, :retry_decision, :outcome, keyword_init: true)
       EntryProcessingResult = Struct.new(
         :created,
         :updated,
@@ -24,7 +26,20 @@ module SourceMonitor
         :created_items,
         :updated_items,
         keyword_init: true
-      )
+      ) do
+        def self.empty
+          new(
+            created: 0,
+            updated: 0,
+            unchanged: 0,
+            failed: 0,
+            items: [],
+            errors: [],
+            created_items: [],
+            updated_items: []
+          )
+        end
+      end
       ResponseWrapper = Struct.new(:status, :headers, :body, keyword_init: true)
 
       attr_reader :source, :client, :jitter_proc
@@ -116,7 +131,6 @@ module SourceMonitor
       end
 
       def handle_success(response, started_at, instrumentation_payload)
-        duration_ms = source_updater.elapsed_ms(started_at)
         body = response.body
         feed_body_signature = body_digest(body)
         feed = parse_feed(body, response)
@@ -125,45 +139,19 @@ module SourceMonitor
           processing = entry_processor.process_feed_entries(feed)
           content_changed = entries_digest_changed?(feed)
         else
-          processing = EntryProcessingResult.new(
-            created: 0,
-            updated: 0,
-            unchanged: 0,
-            failed: 0,
-            items: [],
-            errors: [],
-            created_items: [],
-            updated_items: []
-          )
+          processing = EntryProcessingResult.empty
           content_changed = false
         end
 
-        feed_entries_digest = entries_digest(feed)
-        source_updater.update_source_for_success(response, duration_ms, feed, feed_body_signature, content_changed: content_changed, entries_digest: feed_entries_digest)
-        source_updater.create_fetch_log(
+        SuccessOutcome.new(
           response: response,
-          duration_ms: duration_ms,
-          started_at: started_at,
-          feed: feed,
-          success: true,
           body: body,
+          feed: feed,
+          item_processing: processing,
           feed_signature: feed_body_signature,
-          items_created: processing.created,
-          items_updated: processing.updated,
-          items_failed: processing.failed,
-          item_errors: processing.errors
-        )
-
-        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] = processing.created
-        instrumentation_payload[:items_updated] = processing.updated
-        instrumentation_payload[:items_failed] = processing.failed
-        instrumentation_payload[:retry_attempt] = 0
-
-        Result.new(status: :fetched, feed:, response:, body:, item_processing: processing)
+          content_changed: content_changed,
+          entries_digest: entries_digest(feed)
+        ).apply(source_updater: source_updater, started_at: started_at, instrumentation_payload: instrumentation_payload)
       end
 
       def handle_not_modified(response, started_at, instrumentation_payload)
@@ -189,16 +177,7 @@ module SourceMonitor
           status: :not_modified,
           response: response,
           body: nil,
-          item_processing: EntryProcessingResult.new(
-            created: 0,
-            updated: 0,
-            unchanged: 0,
-            failed: 0,
-            items: [],
-            errors: [],
-            created_items: [],
-            updated_items: []
-          )
+          item_processing: EntryProcessingResult.empty
         )
       end
 
@@ -263,48 +242,8 @@ module SourceMonitor
       end
 
       def handle_failure(error, started_at:, instrumentation_payload:)
-        response = error.response
-        body = response&.body
-        duration_ms = source_updater.elapsed_ms(started_at)
-
-        retry_decision = source_updater.update_source_for_failure(error, duration_ms)
-        source_updater.create_fetch_log(
-          response: response,
-          duration_ms: duration_ms,
-          started_at: started_at,
-          success: false,
-          error: error,
-          body: body
-        )
-
-        instrumentation_payload[:success] = false
-        instrumentation_payload[:status] = :failed
-        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
-
-        Result.new(
-          status: :failed,
-          response: response,
-          body: body,
-          error: error,
-          retry_decision: retry_decision,
-          item_processing: EntryProcessingResult.new(
-            created: 0,
-            updated: 0,
-            unchanged: 0,
-            failed: 0,
-            items: [],
-            errors: [],
-            created_items: [],
-            updated_items: []
-          )
-        )
+        FailureOutcome.new(error: error)
+          .apply(source_updater: source_updater, started_at: started_at, instrumentation_payload: instrumentation_payload)
       end
 
       def attempt_aia_recovery(_error, started_at, instrumentation_payload)

data/lib/source_monitor/fetching/fetch_runner.rb

@@ -78,16 +78,17 @@ module SourceMonitor
         end
 
         # Phase 3: Post-fetch DB writes under the advisory lock (still held).
+        completion_result = completion_result_for(result)
         begin
-          log_handler_result("RetentionHandler", retention_handler.call(source:, result:))
-          log_handler_result("FollowUpHandler", follow_up_handler.call(source:, result:))
-          schedule_retry_if_needed(result)
-          mark_complete!(result)
+          log_handler_result("RetentionHandler", retention_handler.call(source:, result: completion_result))
+          log_handler_result("FollowUpHandler", follow_up_handler.call(source:, result: completion_result))
+          schedule_retry_if_needed(completion_result)
+          mark_complete!(completion_result)
         ensure
           lock.release!
         end
 
-        log_handler_result("EventPublisher", event_publisher.call(source:, result:))
+        log_handler_result("EventPublisher", event_publisher.call(source:, result: result))
         result
       rescue SourceMonitor::Fetching::AdvisoryLock::NotAcquiredError => error
         raise ConcurrencyError, error.message
@@ -156,6 +157,12 @@ module SourceMonitor
         update_source_state(fetch_status: "failed")
       end
 
+      def completion_result_for(result)
+        return result unless result.respond_to?(:outcome)
+
+        result.outcome || result
+      end
+
       def update_source_state(attrs)
         self.class.send(:update_source_state!, source, attrs)
       end