source_monitor 0.1.1

data/lib/source_monitor/health/source_health_reset.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module SourceMonitor
+  module Health
+    class SourceHealthReset
+      def self.call(source:, now: Time.current)
+        new(source:, now:).call
+      end
+
+      def initialize(source:, now: Time.current)
+        @source = source
+        @now = now
+      end
+
+      def call
+        return unless source
+
+        source.with_lock do
+          source.update!(reset_attributes)
+        end
+      end
+
+      private
+
+      attr_reader :source, :now
+
+      def reset_attributes
+        {
+          health_status: "healthy",
+          auto_paused_at: nil,
+          auto_paused_until: nil,
+          rolling_success_rate: nil,
+          failure_count: 0,
+          last_error: nil,
+          last_error_at: nil,
+          backoff_until: nil,
+          fetch_status: "idle",
+          fetch_retry_attempt: 0,
+          fetch_circuit_opened_at: nil,
+          fetch_circuit_until: nil,
+          next_fetch_at: computed_next_fetch_at,
+          updated_at: now
+        }
+      end
+
+      def computed_next_fetch_at
+        minutes = effective_fetch_interval_minutes
+        return nil unless minutes
+
+        now + minutes.minutes
+      end
+
+      def effective_fetch_interval_minutes
+        explicit = source.fetch_interval_minutes
+        return normalize_interval(explicit) if explicit.present?
+
+        SourceMonitor.config.fetching.min_interval_minutes
+      end
+
+      def normalize_interval(value)
+        return nil if value.nil?
+
+        integer = value.to_i
+        integer.positive? ? integer : nil
+      end
+    end
+  end
+end

data/lib/source_monitor/health.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "source_monitor/health/source_health_monitor"
+require "source_monitor/health/source_health_reset"
+require "source_monitor/health/source_health_check"
+
+module SourceMonitor
+  module Health
+    module_function
+
+    def setup!
+      register_fetch_callback
+    end
+
+    def fetch_callback
+      @fetch_callback ||= lambda do |event|
+        source = event&.source
+        next unless source
+
+        SourceHealthMonitor.new(source: source).call
+      rescue StandardError => error
+        log_error(source, error)
+      end
+    end
+
+    def register_fetch_callback
+      callbacks = SourceMonitor.config.events.callbacks_for(:after_fetch_completed)
+      return if callbacks.include?(fetch_callback)
+
+      SourceMonitor.config.events.after_fetch_completed(fetch_callback)
+    end
+    private_class_method :register_fetch_callback
+
+    def log_error(source, error)
+      message = "[SourceMonitor] Source health monitor failed for #{source&.id || 'unknown'}: #{error.class}: #{error.message}"
+      if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+        Rails.logger.error(message)
+      else
+        warn(message)
+      end
+    rescue StandardError
+      warn(message)
+    end
+    private_class_method :log_error
+  end
+end

data/lib/source_monitor/http.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/retry"
+require "faraday/follow_redirects"
+require "faraday/gzip"
+require "active_support/core_ext/object/blank"
+
+module SourceMonitor
+  module HTTP
+    DEFAULT_TIMEOUT = 15
+    DEFAULT_OPEN_TIMEOUT = 5
+    DEFAULT_MAX_REDIRECTS = 5
+    DEFAULT_USER_AGENT = "SourceMonitor/#{SourceMonitor::VERSION}"
+    RETRY_STATUSES = [ 429, 500, 502, 503, 504 ].freeze
+
+    class << self
+      def client(proxy: nil, headers: {}, timeout: nil, open_timeout: nil, retry_requests: true)
+        settings = SourceMonitor.config.http
+
+        effective_proxy = resolve_proxy(proxy, settings)
+        effective_timeout = timeout || settings.timeout || DEFAULT_TIMEOUT
+        effective_open_timeout = open_timeout || settings.open_timeout || DEFAULT_OPEN_TIMEOUT
+
+        Faraday.new(nil, proxy: effective_proxy) do |connection|
+          configure_request(
+            connection,
+            headers,
+            timeout: effective_timeout,
+            open_timeout: effective_open_timeout,
+            settings: settings,
+            enable_retry: retry_requests
+          )
+        end
+      end
+
+      private
+
+      def configure_request(connection, headers, timeout:, open_timeout:, settings:, enable_retry:) # rubocop:disable Metrics/MethodLength
+        if enable_retry
+          connection.request :retry,
+                             max: settings.retry_max || 4,
+                             interval: settings.retry_interval || 0.5,
+                             interval_randomness: settings.retry_interval_randomness || 0.5,
+                             backoff_factor: settings.retry_backoff_factor || 2,
+                             retry_statuses: settings.retry_statuses || RETRY_STATUSES
+        end
+        connection.request :gzip
+
+        connection.response :follow_redirects, limit: settings.max_redirects || DEFAULT_MAX_REDIRECTS
+        connection.response :raise_error
+
+        connection.options.timeout = timeout
+        connection.options.open_timeout = open_timeout
+
+        default_headers(settings).merge(headers).each do |key, value|
+          connection.headers[key] = value
+        end
+
+        connection.adapter Faraday.default_adapter
+      end
+
+      def default_headers(settings)
+        base_headers = {
+          "User-Agent" => resolve_callable(settings.user_agent).presence || DEFAULT_USER_AGENT,
+          "Accept" => "application/rss+xml, application/atom+xml, application/json;q=0.9, text/xml;q=0.8",
+          "Accept-Encoding" => "gzip,deflate"
+        }
+
+        base_headers.merge(settings.headers || {})
+      end
+
+      def resolve_proxy(proxy, settings)
+        return nil if proxy == false
+        return proxy unless proxy.nil?
+
+        resolve_callable(settings.proxy)
+      end
+
+      def resolve_callable(value)
+        value.respond_to?(:call) ? value.call : value
+      end
+    end
+  end
+end

data/lib/source_monitor/instrumentation.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+module SourceMonitor
+  module Instrumentation
+    FETCH_START_EVENT = "source_monitor.fetch.start".freeze
+    FETCH_FINISH_EVENT = "source_monitor.fetch.finish".freeze
+    ITEM_DUPLICATE_EVENT = "source_monitor.items.duplicate".freeze
+    ITEM_RETENTION_EVENT = "source_monitor.items.retention".freeze
+
+    module_function
+
+    def fetch(payload = {})
+      payload = payload.dup
+      instrument(FETCH_START_EVENT, payload)
+
+      started_at = monotonic_time
+      result = yield if block_given?
+      duration_ms = ((monotonic_time - started_at) * 1000.0).round(2)
+
+      instrument(FETCH_FINISH_EVENT, payload.merge(duration_ms: duration_ms))
+      result
+    end
+
+    def fetch_start(payload = {})
+      instrument(FETCH_START_EVENT, payload)
+    end
+
+    def fetch_finish(payload = {})
+      instrument(FETCH_FINISH_EVENT, payload)
+    end
+
+    def item_duplicate(payload = {})
+      instrument(ITEM_DUPLICATE_EVENT, payload)
+    end
+
+    def item_retention(payload = {})
+      instrument(ITEM_RETENTION_EVENT, payload)
+    end
+
+    def instrument(event_name, payload = {})
+      ActiveSupport::Notifications.instrument(event_name, payload) do
+        yield if block_given?
+      end
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end