desiru 0.1.0 → 0.1.1

data/lib/desiru/jobs/retriable.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative 'retry_strategies'
+
+module Desiru
+  module Jobs
+    # Mixin for adding advanced retry capabilities to jobs
+    module Retriable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Configure retry policy for the job class
+        def retry_policy(policy = nil)
+          if policy
+            @retry_policy = policy
+          else
+            @retry_policy ||= RetryStrategies::RetryPolicy.new
+          end
+        end
+
+        # DSL for configuring retry policy
+        def configure_retries(max_retries: nil, strategy: nil, retriable: nil, non_retriable: nil)
+          policy_options = {}
+          policy_options[:max_retries] = max_retries if max_retries
+          policy_options[:retry_strategy] = strategy if strategy
+          policy_options[:retriable_errors] = retriable if retriable
+          policy_options[:non_retriable_errors] = non_retriable if non_retriable
+
+          @retry_policy = RetryStrategies::RetryPolicy.new(**policy_options)
+        end
+      end
+
+      # Wrap job execution with retry logic
+      def perform_with_retries(*args)
+        retry_count = 0
+        job_id = args.first if args.first.is_a?(String)
+
+        begin
+          # Track retry count in job result if persistence is enabled
+          if job_id && respond_to?(:persistence_enabled?) && persistence_enabled?
+            update_retry_count(job_id, retry_count)
+          end
+
+          perform_without_retries(*args)
+        rescue StandardError => e
+          policy = self.class.retry_policy
+
+          if policy.should_retry?(retry_count, e)
+            retry_count += 1
+            delay = policy.retry_delay(retry_count)
+
+            log_retry(e, retry_count, delay)
+
+            # Schedule retry with delay
+            self.class.perform_in(delay, *args)
+
+            # Don't re-raise - we've scheduled a retry
+            nil
+          else
+            # Max retries exceeded or non-retriable error
+            log_retry_failure(e, retry_count)
+
+            # Mark job as failed if persistence is enabled
+            persist_error_to_db(job_id, e, e.backtrace) if job_id && respond_to?(:persist_error_to_db)
+
+            # Re-raise to let Sidekiq handle it
+            raise
+          end
+        end
+      end
+
+      private
+
+      def update_retry_count(job_id, count)
+        return unless respond_to?(:job_repo) && job_repo
+
+        job_result = job_repo.find_by_job_id(job_id)
+        job_result&.update(retry_count: count)
+      rescue StandardError => e
+        Desiru.logger.warn("Failed to update retry count: #{e.message}")
+      end
+
+      def log_retry(error, retry_count, delay)
+        Desiru.logger.warn(
+          "Retrying #{self.class.name} after error: #{error.message}. " \
+          "Retry #{retry_count}, waiting #{delay.round(2)}s"
+        )
+      end
+
+      def log_retry_failure(error, retry_count)
+        Desiru.logger.error(
+          "#{self.class.name} failed after #{retry_count} retries: #{error.message}"
+        )
+      end
+    end
+
+    # Enhanced base job with retry capabilities
+    class RetriableJob < Base
+      include Retriable
+
+      # Alias the original perform method
+      alias perform_without_retries perform
+      alias perform perform_with_retries
+
+      # Default configuration with exponential backoff
+      configure_retries(
+        max_retries: 5,
+        strategy: RetryStrategies::ExponentialBackoff.new,
+        non_retriable: [
+          ArgumentError,
+          NoMethodError,
+          SyntaxError
+        ]
+      )
+    end
+  end
+end

data/lib/desiru/jobs/retry_strategies.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Desiru
+  module Jobs
+    # Advanced retry strategies for background jobs
+    module RetryStrategies
+      # Exponential backoff with jitter
+      class ExponentialBackoff
+        attr_reader :base_delay, :max_delay, :multiplier, :jitter
+
+        def initialize(base_delay: 1, max_delay: 300, multiplier: 2, jitter: true)
+          @base_delay = base_delay
+          @max_delay = max_delay
+          @multiplier = multiplier
+          @jitter = jitter
+        end
+
+        # Calculate delay for the given retry attempt
+        def delay_for(retry_count)
+          delay = [base_delay * (multiplier**retry_count), max_delay].min
+
+          if jitter
+            # Add random jitter (±25%) to prevent thundering herd
+            jitter_amount = delay * 0.25
+            jittered_delay = delay + ((rand * 2 * jitter_amount) - jitter_amount)
+            # Ensure we don't exceed max_delay even with jitter
+            [jittered_delay, max_delay].min
+          else
+            delay
+          end
+        end
+      end
+
+      # Linear backoff strategy
+      class LinearBackoff
+        attr_reader :base_delay, :max_delay, :increment
+
+        def initialize(base_delay: 1, max_delay: 60, increment: 5)
+          @base_delay = base_delay
+          @max_delay = max_delay
+          @increment = increment
+        end
+
+        def delay_for(retry_count)
+          [base_delay + (increment * retry_count), max_delay].min
+        end
+      end
+
+      # Fixed delay strategy
+      class FixedDelay
+        attr_reader :delay
+
+        def initialize(delay: 5)
+          @delay = delay
+        end
+
+        def delay_for(_retry_count)
+          delay
+        end
+      end
+
+      # Custom retry policy
+      class RetryPolicy
+        attr_reader :max_retries, :retry_strategy, :retriable_errors, :non_retriable_errors
+
+        def initialize(
+          max_retries: 5,
+          retry_strategy: ExponentialBackoff.new,
+          retriable_errors: nil,
+          non_retriable_errors: nil
+        )
+          @max_retries = max_retries
+          @retry_strategy = retry_strategy
+          @retriable_errors = Array(retriable_errors) if retriable_errors
+          @non_retriable_errors = Array(non_retriable_errors) if non_retriable_errors
+        end
+
+        # Check if error is retriable
+        def retriable?(error)
+          # If non-retriable errors are specified, check those first
+          return false if non_retriable_errors&.any? { |klass| error.is_a?(klass) }
+
+          # If retriable errors are specified, only retry those
+          if retriable_errors
+            # Only retry if the error matches one of the specified retriable errors
+            retriable_errors.any? { |klass| error.is_a?(klass) }
+          else
+            # By default, retry all errors except non-retriable ones
+            true
+          end
+        end
+
+        # Check if we should retry based on count
+        def should_retry?(retry_count, error)
+          retry_count < max_retries && retriable?(error)
+        end
+
+        # Get delay for the current retry
+        def retry_delay(retry_count)
+          retry_strategy.delay_for(retry_count)
+        end
+      end
+
+      # Circuit breaker pattern
+      class CircuitBreaker
+        attr_reader :failure_threshold, :timeout, :half_open_requests
+
+        def initialize(failure_threshold: 5, timeout: 60, half_open_requests: 1)
+          @failure_threshold = failure_threshold
+          @timeout = timeout
+          @half_open_requests = half_open_requests
+          @state = :closed
+          @failure_count = 0
+          @last_failure_time = nil
+          @half_open_count = 0
+        end
+
+        def call
+          case @state
+          when :open
+            raise CircuitOpenError, "Circuit breaker is open" unless Time.now - @last_failure_time >= timeout
+
+            @state = :half_open
+            @half_open_count = 0
+
+          end
+
+          begin
+            result = yield
+            on_success
+            result
+          rescue StandardError => e
+            on_failure
+            raise e
+          end
+        end
+
+        private
+
+        def on_success
+          case @state
+          when :half_open
+            @half_open_count += 1
+            if @half_open_count >= half_open_requests
+              @state = :closed
+              @failure_count = 0
+            end
+          when :closed
+            @failure_count = 0
+          end
+        end
+
+        def on_failure
+          @failure_count += 1
+          @last_failure_time = Time.now
+
+          case @state
+          when :closed
+            @state = :open if @failure_count >= failure_threshold
+          when :half_open
+            @state = :open
+          end
+        end
+
+        class CircuitOpenError < StandardError; end
+      end
+    end
+  end
+end

data/lib/desiru/jobs/scheduler.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Desiru
+  module Jobs
+    # Simple cron-like scheduler for Sidekiq jobs
+    class Scheduler
+      include Singleton
+
+      attr_reader :jobs
+
+      def initialize
+        @jobs = {}
+        @running = false
+        @thread = nil
+      end
+
+      # Schedule a job to run periodically
+      # @param name [String] unique name for the scheduled job
+      # @param job_class [Class] the job class to execute
+      # @param cron [String] cron expression or simple interval
+      # @param args [Array] arguments to pass to the job
+      # @param options [Hash] additional options
+      def schedule(name, job_class:, cron:, args: [], **options)
+        @jobs[name] = {
+          job_class: job_class,
+          cron: cron,
+          args: args,
+          options: options,
+          last_run: nil,
+          next_run: calculate_next_run(cron, nil)
+        }
+      end
+
+      # Remove a scheduled job
+      def unschedule(name)
+        @jobs.delete(name)
+      end
+
+      # Start the scheduler
+      def start
+        return if @running
+
+        @running = true
+        @thread = Thread.new do
+          while @running
+            check_and_run_jobs
+            sleep 1 # Check every second
+          end
+        end
+      end
+
+      # Stop the scheduler
+      def stop
+        @running = false
+        @thread&.join
+      end
+
+      # Check if scheduler is running
+      def running?
+        @running
+      end
+
+      # Clear all scheduled jobs
+      def clear
+        @jobs.clear
+      end
+
+      # Get information about a scheduled job
+      def job_info(name)
+        @jobs[name]
+      end
+
+      private
+
+      def check_and_run_jobs
+        current_time = Time.now
+
+        @jobs.each do |name, job_config|
+          next unless should_run?(job_config, current_time)
+
+          run_job(name, job_config)
+          job_config[:last_run] = current_time
+          job_config[:next_run] = calculate_next_run(job_config[:cron], current_time)
+        end
+      rescue StandardError => e
+        Desiru.logger.error("Scheduler error: #{e.message}")
+      end
+
+      def should_run?(job_config, current_time)
+        job_config[:next_run] && current_time >= job_config[:next_run]
+      end
+
+      def run_job(name, job_config)
+        job_class = job_config[:job_class]
+        args = job_config[:args]
+
+        # Generate unique job ID for scheduled jobs
+        job_id = "scheduled-#{name}-#{Time.now.to_i}"
+
+        # Enqueue the job
+        if job_class.respond_to?(:perform_async)
+          if args.empty?
+            job_class.perform_async(job_id)
+          else
+            job_class.perform_async(job_id, *args)
+          end
+
+          Desiru.logger.info("Scheduled job #{name} enqueued with ID: #{job_id}")
+        else
+          Desiru.logger.error("Job class #{job_class} does not respond to perform_async")
+        end
+      rescue StandardError => e
+        Desiru.logger.error("Failed to enqueue scheduled job #{name}: #{e.message}")
+      end
+
+      def calculate_next_run(cron_expression, last_run)
+        case cron_expression
+        when /^\d+$/ # Simple interval in seconds
+          interval = cron_expression.to_i
+          base_time = last_run || Time.now
+          base_time + interval
+        when /^every (\d+) (second|minute|hour|day)s?$/i
+          # Handle simple interval expressions like "every 5 minutes"
+          amount = ::Regexp.last_match(1).to_i
+          unit = ::Regexp.last_match(2).downcase
+
+          interval = case unit
+                     when 'second' then amount
+                     when 'minute' then amount * 60
+                     when 'hour' then amount * 3600
+                     when 'day' then amount * 86_400
+                     end
+
+          base_time = last_run || Time.now
+          base_time + interval
+        else
+          # For now, we'll support simple cron patterns
+          parse_cron_expression(cron_expression, last_run)
+        end
+      end
+
+      def parse_cron_expression(cron_expression, last_run)
+        # Simple cron parser for common patterns
+        # Format: minute hour day month weekday
+        parts = cron_expression.split
+
+        case parts.length
+        when 5
+          # Full cron expression - for now, just support simple patterns
+          minute, hour, = parts
+
+          if minute == '*' && hour == '*'
+            # Every minute
+            (last_run || Time.now) + 60
+          elsif minute =~ /^\d+$/ && hour == '*'
+            # Every hour at specific minute
+            next_time = last_run || Time.now
+            next_time + (((60 - next_time.min + minute.to_i) % 60) * 60)
+
+          elsif minute =~ /^\d+$/ && hour =~ /^\d+$/
+            # Daily at specific time
+            target_hour = hour.to_i
+            target_minute = minute.to_i
+
+            next_time = Time.now
+            next_time = Time.new(next_time.year, next_time.month, next_time.day, target_hour, target_minute, 0)
+
+            # If we've already passed this time today, schedule for tomorrow
+            if next_time <= Time.now
+              next_time += 86_400 # Add one day
+            end
+
+            next_time
+          else
+            # Unsupported pattern, default to hourly
+            (last_run || Time.now) + 3600
+          end
+        else
+          # Invalid cron expression, default to hourly
+          Desiru.logger.warn("Invalid cron expression: #{cron_expression}, defaulting to hourly")
+          (last_run || Time.now) + 3600
+        end
+      end
+    end
+
+    # Mixin for making jobs schedulable
+    module Schedulable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Schedule this job to run periodically
+        def schedule(cron:, name: nil, args: [], **)
+          job_name = name || self.name
+          Scheduler.instance.schedule(job_name,
+                                      job_class: self,
+                                      cron: cron,
+                                      args: args,
+                                      **)
+        end
+
+        # Remove this job from the schedule
+        def unschedule(name: nil)
+          job_name = name || self.name
+          Scheduler.instance.unschedule(job_name)
+        end
+
+        # Check if this job is scheduled
+        def scheduled?(name: nil)
+          job_name = name || self.name
+          Scheduler.instance.job_info(job_name) != nil
+        end
+      end
+    end
+  end
+end