canvas_sync 0.21.1 → 0.22.0.beta1

data/lib/canvas_sync/job_batches/chain_builder.rb

@@ -1,249 +1,247 @@
-module CanvasSync
-  module JobBatches
-    class ChainBuilder
-      VALID_PLACEMENT_PARAMETERS = %i[before after with].freeze
-
-      attr_reader :base_job
-
-      def initialize(base_type = SerialBatchJob)
-        if base_type.is_a?(Hash)
-          @base_job = base_type
-          @base_job[:args] ||= @base_job[:parameters] || []
-          @base_job[:kwargs] ||= {}
-        else
-          @base_job = build_job_hash(base_type)
-        end
-
-        self.class.get_chain_parameter(base_job)
+module CanvasSync::JobBatches
+  class ChainBuilder
+    VALID_PLACEMENT_PARAMETERS = %i[before after with].freeze
+
+    attr_reader :base_job
+
+    def initialize(base_type = SerialBatchJob)
+      if base_type.is_a?(Hash)
+        @base_job = base_type
+        @base_job[:args] ||= @base_job[:parameters] || []
+        @base_job[:kwargs] ||= {}
+      else
+        @base_job = build_job_hash(base_type)
       end
 
-      def process!
-        normalize!
-        self.class.enqueue_job(base_job)
-      end
+      self.class.get_chain_parameter(base_job)
+    end
 
-      def [](key)
-        if key.is_a?(Class)
-          get_sub_chain(key)
-        else
-          # Legacy Support
-          key = :args if key == :parameters
+    def process!
+      normalize!
+      self.class.enqueue_job(base_job)
+    end
 
-          @base_job[key]
-        end
+    def [](key)
+      if key.is_a?(Class)
+        get_sub_chain(key)
+      else
+        # Legacy Support
+        key = :args if key == :parameters
+
+        @base_job[key]
       end
+    end
 
-      def args; return self[:args]; end
-      def kwargs; return self[:kwargs]; end
+    def args; return self[:args]; end
+    def kwargs; return self[:kwargs]; end
 
-      def <<(new_job)
-        insert_at(-1, new_job)
+    def <<(new_job)
+      insert_at(-1, new_job)
+    end
+
+    def insert_at(position, new_jobs, *args, **kwargs, &blk)
+      chain = self.class.get_chain_parameter(base_job)
+      if new_jobs.is_a?(Class) || new_jobs.is_a?(String)
+        new_jobs = build_job_hash(new_jobs, args: args, kwargs: kwargs, &blk)
+      elsif args.count > 0 || kwargs.count > 0
+        raise "Unexpected number of arguments"
       end
+      new_jobs = [new_jobs] unless new_jobs.is_a?(Array)
+      chain.insert(position, *new_jobs)
+    end
 
-      def insert_at(position, new_jobs, *args, **kwargs, &blk)
-        chain = self.class.get_chain_parameter(base_job)
-        if new_jobs.is_a?(Class) || new_jobs.is_a?(String)
-          new_jobs = build_job_hash(new_jobs, args: args, kwargs: kwargs, &blk)
-        elsif args.count > 0 || kwargs.count > 0
-          raise "Unexpected number of arguments"
-        end
-        new_jobs = [new_jobs] unless new_jobs.is_a?(Array)
-        chain.insert(position, *new_jobs)
+    def insert(new_jobs, *args, **kwargs, &blk)
+      if new_jobs.is_a?(Class) || new_jobs.is_a?(String)
+        job_kwargs = kwargs.except(*VALID_PLACEMENT_PARAMETERS)
+        new_jobs = build_job_hash(new_jobs, args: args, kwargs: job_kwargs, &blk)
+        kwargs = kwargs.slice(*VALID_PLACEMENT_PARAMETERS)
+      else
+        invalid_params = kwargs.keys - VALID_PLACEMENT_PARAMETERS
+        raise "Invalid placement parameters: #{invalid_params.map(&:to_s).join(', ')}" if invalid_params.present?
+        raise "At most one placement parameter may be provided" if kwargs.values.compact.length > 1
+        raise "Unexpected number of arguments" if args.length > 0
       end
 
-      def insert(new_jobs, *args, **kwargs, &blk)
-        if new_jobs.is_a?(Class) || new_jobs.is_a?(String)
-          job_kwargs = kwargs.except(*VALID_PLACEMENT_PARAMETERS)
-          new_jobs = build_job_hash(new_jobs, args: args, kwargs: job_kwargs, &blk)
-          kwargs = kwargs.slice(*VALID_PLACEMENT_PARAMETERS)
-        else
-          invalid_params = kwargs.keys - VALID_PLACEMENT_PARAMETERS
-          raise "Invalid placement parameters: #{invalid_params.map(&:to_s).join(', ')}" if invalid_params.present?
-          raise "At most one placement parameter may be provided" if kwargs.values.compact.length > 1
-          raise "Unexpected number of arguments" if args.length > 0
-        end
+      new_jobs = [new_jobs] unless new_jobs.is_a?(Array)
 
-        new_jobs = [new_jobs] unless new_jobs.is_a?(Array)
+      if !kwargs.present?
+        insert_at(-1, new_jobs)
+      else
+        placement = kwargs.keys[0]
+        relative_to = kwargs.values[0]
 
-        if !kwargs.present?
-          insert_at(-1, new_jobs)
-        else
-          placement = kwargs.keys[0]
-          relative_to = kwargs.values[0]
+        matching_jobs = find_matching_jobs(relative_to).to_a
+        raise "Could not find a \"#{relative_to}\" job in the chain" if matching_jobs.count == 0
+        raise "Found multiple \"#{relative_to}\" jobs in the chain" if matching_jobs.count > 1
 
-          matching_jobs = find_matching_jobs(relative_to).to_a
-          raise "Could not find a \"#{relative_to}\" job in the chain" if matching_jobs.count == 0
-          raise "Found multiple \"#{relative_to}\" jobs in the chain" if matching_jobs.count > 1
+        relative_job, parent_job, sub_index = matching_jobs[0]
+        needed_parent_type = placement == :with ? ConcurrentBatchJob : SerialBatchJob
 
-          relative_job, parent_job, sub_index = matching_jobs[0]
-          needed_parent_type = placement == :with ? ConcurrentBatchJob : SerialBatchJob
+        chain = self.class.get_chain_parameter(parent_job)
 
+        if parent_job[:job] != needed_parent_type
+          old_job = chain[sub_index]
+          parent_job = chain[sub_index] = {
+            job: needed_parent_type,
+            parameters: [],
+          }
+          sub_index = 0
           chain = self.class.get_chain_parameter(parent_job)
+          chain << old_job
+        end
 
-          if parent_job[:job] != needed_parent_type
-            old_job = chain[sub_index]
-            parent_job = chain[sub_index] = {
-              job: needed_parent_type,
-              parameters: [],
-            }
-            sub_index = 0
-            chain = self.class.get_chain_parameter(parent_job)
-            chain << old_job
-          end
-
-          if placement == :with
-            chain.insert(-1, *new_jobs)
-          else
-            sub_index += 1 if placement == :after
-            chain.insert(sub_index, *new_jobs)
-          end
+        if placement == :with
+          chain.insert(-1, *new_jobs)
+        else
+          sub_index += 1 if placement == :after
+          chain.insert(sub_index, *new_jobs)
         end
       end
+    end
 
-      def empty?
-        self.class.get_chain_parameter(self).empty?
-      end
+    def empty?
+      self.class.get_chain_parameter(self).empty?
+    end
 
-      def get_sub_chain(sub_type)
-        matching_jobs = find_matching_jobs(sub_type).to_a
-        raise "Found multiple \"#{sub_type}\" jobs in the chain" if matching_jobs.count > 1
-        return nil if matching_jobs.count == 0
+    def get_sub_chain(sub_type)
+      matching_jobs = find_matching_jobs(sub_type).to_a
+      raise "Found multiple \"#{sub_type}\" jobs in the chain" if matching_jobs.count > 1
+      return nil if matching_jobs.count == 0
 
-        job = matching_jobs[0][0]
-        job = self.class.new(job) unless job.is_a?(ChainBuilder)
-        job
-      end
+      job = matching_jobs[0][0]
+      job = self.class.new(job) unless job.is_a?(ChainBuilder)
+      job
+    end
 
-      def normalize!(job_def = self.base_job)
-        if job_def.is_a?(ChainBuilder)
-          job_def.normalize!
-        else
-          job_def[:job] = job_def[:job].to_s
-          if (chain = self.class.get_chain_parameter(job_def, raise_error: false)).present?
-            chain.map! { |sub_job| normalize!(sub_job) }
-          end
-          job_def
+    def normalize!(job_def = self.base_job)
+      if job_def.is_a?(ChainBuilder)
+        job_def.normalize!
+      else
+        job_def[:job] = job_def[:job].to_s
+        if (chain = self.class.get_chain_parameter(job_def, raise_error: false)).present?
+          chain.map! { |sub_job| normalize!(sub_job) }
         end
+        job_def
       end
+    end
 
-      def apply_block(&blk)
-        return unless blk.present?
-        instance_exec(&blk)
-      end
+    def apply_block(&blk)
+      return unless blk.present?
+      instance_exec(&blk)
+    end
 
-      private
+    private
 
-      def build_job_hash(job, args: [], kwargs: {}, &blk)
-        hsh = {
-          job: job,
-          args: args,
-          kwargs: kwargs,
-        }
-        self.class.new(hsh).apply_block(&blk) if blk.present?
-        hsh
-      end
+    def build_job_hash(job, args: [], kwargs: {}, &blk)
+      hsh = {
+        job: job,
+        args: args,
+        kwargs: kwargs,
+      }
+      self.class.new(hsh).apply_block(&blk) if blk.present?
+      hsh
+    end
 
-      def find_matching_jobs(search_job, parent_job = self.base_job)
-        return to_enum(:find_matching_jobs, search_job, parent_job) unless block_given?
+    def find_matching_jobs(search_job, parent_job = self.base_job)
+      return to_enum(:find_matching_jobs, search_job, parent_job) unless block_given?
 
-        sub_jobs = self.class.get_chain_parameter(parent_job)
-        sub_jobs.each_with_index do |sub_job, i|
-          if sub_job[:job].to_s == search_job.to_s
-            yield [sub_job, parent_job, i]
-          elsif self.class._job_type_definitions[sub_job[:job].to_s]
-            find_matching_jobs(search_job, sub_job) { |item| yield item }
-          end
+      sub_jobs = self.class.get_chain_parameter(parent_job)
+      sub_jobs.each_with_index do |sub_job, i|
+        if sub_job[:job].to_s == search_job.to_s
+          yield [sub_job, parent_job, i]
+        elsif self.class._job_type_definitions[sub_job[:job].to_s]
+          find_matching_jobs(search_job, sub_job) { |item| yield item }
         end
       end
+    end
 
-      def find_parent_job(job_def)
-        iterate_job_tree do |job, path|
-          return path[-1] if job == job_def
-        end
-        nil
+    def find_parent_job(job_def)
+      iterate_job_tree do |job, path|
+        return path[-1] if job == job_def
       end
+      nil
+    end
 
-      def iterate_job_tree(root: self.base_job, path: [], &blk)
-        blk.call(root, path)
+    def iterate_job_tree(root: self.base_job, path: [], &blk)
+      blk.call(root, path)
 
-        if self.class._job_type_definitions[root[:job]]
-          sub_jobs = self.class.get_chain_parameter(root)
-          sub_jobs.each_with_index do |sub_job, i|
-            iterate_job_tree(root: sub_job, path: [*path, root], &blk)
-          end
+      if self.class._job_type_definitions[root[:job]]
+        sub_jobs = self.class.get_chain_parameter(root)
+        sub_jobs.each_with_index do |sub_job, i|
+          iterate_job_tree(root: sub_job, path: [*path, root], &blk)
         end
       end
+    end
 
-      class << self
-        # Support builder syntaxt/DSL
-        # Chain.build(ConcurrentBatchJob) do
-        #   insert(SomeJob, arg1, kwarg: 1)
-        #   insert(SerialBatchJob) do
-        #     insert(SomeJob, arg1, kwarg: 1)
-        #   end
-        # end
-        def build(job, *args, **kwargs, &blk)
-          new(job).tap do |ch|
-            ch.base_job[:args] = args
-            ch.base_job[:kwargs] = kwargs
-            ch.apply_block(&blk)
-          end
+    class << self
+      # Support builder syntaxt/DSL
+      # Chain.build(ConcurrentBatchJob) do
+      #   insert(SomeJob, arg1, kwarg: 1)
+      #   insert(SerialBatchJob) do
+      #     insert(SomeJob, arg1, kwarg: 1)
+      #   end
+      # end
+      def build(job, *args, **kwargs, &blk)
+        new(job).tap do |ch|
+          ch.base_job[:args] = args
+          ch.base_job[:kwargs] = kwargs
+          ch.apply_block(&blk)
         end
+      end
+
+      def _job_type_definitions
+        @job_type_definitions ||= {}
+      end
+
+      def register_chain_job(job_class, chain_parameter, **options)
+        _job_type_definitions[job_class.to_s] = {
+          **options,
+          chain_parameter: chain_parameter,
+        }
+      end
 
-        def _job_type_definitions
-          @job_type_definitions ||= {}
+      def get_chain_parameter(job_def, raise_error: true)
+        unless _job_type_definitions[job_def[:job].to_s].present?
+          raise "Job Type #{job_def[:job].to_s} does not accept a sub-chain" if raise_error
+          return nil
         end
 
-        def register_chain_job(job_class, chain_parameter, **options)
-          _job_type_definitions[job_class.to_s] = {
-            **options,
-            chain_parameter: chain_parameter,
-          }
+        key = _job_type_definitions[job_def[:job].to_s][:chain_parameter]
+        if key.is_a?(Numeric)
+          job_def[:args][key] ||= []
+        else
+          job_def[:kwargs][key] ||= []
         end
+      end
 
-        def get_chain_parameter(job_def, raise_error: true)
-          unless _job_type_definitions[job_def[:job].to_s].present?
-            raise "Job Type #{job_def[:job].to_s} does not accept a sub-chain" if raise_error
-            return nil
-          end
-
-          key = _job_type_definitions[job_def[:job].to_s][:chain_parameter]
-          if key.is_a?(Numeric)
-            job_def[:args][key] ||= []
-          else
-            job_def[:kwargs][key] ||= []
-          end
+      # TODO: Add a Chain progress web View
+      # Augment Batch tree-view with Chain data
+      #   > [DONE] Tree view w/o Chain will only show Parent/Current batches and Job Counts
+      #   > If augmented with Chain data, the above will be annotated with Chain-related info and will be able to show Jobs defined in the Chain
+      #     > Chain-jobs will be supplied chain_id and chain_step_id metadata
+      #     > Using server-middleware, if a Chain-job (has chain_id and chain_step_id) creates a Batch, tag the Batch w/ the chain_id and chain_step_id
+      #     > UI will map Batches to Chain-steps using the chain_step_id. UI will add entries for any Chain-steps that were not tied to a Batch
+      #   > [DONE] Use a Lua script to find child batch IDs. Support max_depth, items_per_depth, top_depth_slice parameters
+      def enqueue_job(job_def)
+        job_class = job_def[:job].constantize
+        job_args = job_def[:args] || job_def[:parameters] || []
+        job_kwargs = job_def[:kwargs] || {}
+
+        # Legacy Support
+        if job_def[:options]
+          job_args << {} unless job_args[-1].is_a?(Hash)
+          job_args[-1].merge!(job_def[:options])
         end
 
-        # TODO: Add a Chain progress web View
-        # Augment Batch tree-view with Chain data
-        #   > [DONE] Tree view w/o Chain will only show Parent/Current batches and Job Counts
-        #   > If augmented with Chain data, the above will be annotated with Chain-related info and will be able to show Jobs defined in the Chain
-        #     > Chain-jobs will be supplied chain_id and chain_step_id metadata
-        #     > Using server-middleware, if a Chain-job (has chain_id and chain_step_id) creates a Batch, tag the Batch w/ the chain_id and chain_step_id
-        #     > UI will map Batches to Chain-steps using the chain_step_id. UI will add entries for any Chain-steps that were not tied to a Batch
-        #   > [DONE] Use a Lua script to find child batch IDs. Support max_depth, items_per_depth, top_depth_slice parameters
-        def enqueue_job(job_def)
-          job_class = job_def[:job].constantize
-          job_args = job_def[:args] || job_def[:parameters] || []
-          job_kwargs = job_def[:kwargs] || {}
-
-          # Legacy Support
-          if job_def[:options]
-            job_args << {} unless job_args[-1].is_a?(Hash)
-            job_args[-1].merge!(job_def[:options])
-          end
-
-          if job_class.respond_to? :perform_async
-            job_class.perform_async(*job_args, **job_kwargs)
-          else
-            job_class.perform_later(*job_args, **job_kwargs)
-          end
+        if job_class.respond_to? :perform_async
+          job_class.perform_async(*job_args, **job_kwargs)
+        else
+          job_class.perform_later(*job_args, **job_kwargs)
         end
       end
     end
-
-    ChainBuilder.register_chain_job(ConcurrentBatchJob, 0)
-    ChainBuilder.register_chain_job(SerialBatchJob, 0)
   end
+
+  ChainBuilder.register_chain_job(ConcurrentBatchJob, 0)
+  ChainBuilder.register_chain_job(SerialBatchJob, 0)
 end

data/lib/canvas_sync/job_batches/{active_job.rb → compat/active_job.rb}

@@ -1,6 +1,6 @@
 
-module CanvasSync
-  module JobBatches
+module CanvasSync::JobBatches
+  module Compat
     module ActiveJob
       module BatchAwareJob
         extend ActiveSupport::Concern

data/lib/canvas_sync/job_batches/{sidekiq → compat/sidekiq}/web/helpers.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module CanvasSync::JobBatches::Sidekiq
+module CanvasSync::JobBatches::Compat::Sidekiq
   module Web
     module Helpers
       VIEW_PATH    = File.expand_path("../web/views", __dir__)

data/lib/canvas_sync/job_batches/{sidekiq → compat/sidekiq}/web.rb

@@ -7,7 +7,7 @@ end
 
 require_relative "web/helpers"
 
-module CanvasSync::JobBatches::Sidekiq
+module CanvasSync::JobBatches::Compat::Sidekiq
   module Web
     DEV_MODE = (defined?(Rails) && !Rails.env.production?) || !!ENV["SIDEKIQ_WEB_TESTING"]
     Sidekiq::WebHelpers::SAFE_QPARAMS << 'all_batches'
@@ -204,14 +204,14 @@ end
 
 if defined?(::Sidekiq::Web)
   rules = []
-  rules = [[:all, {"Cache-Control" => "public, max-age=86400"}]] unless CanvasSync::JobBatches::Sidekiq::Web::DEV_MODE
+  rules = [[:all, {"Cache-Control" => "public, max-age=86400"}]] unless CanvasSync::JobBatches::Compat::Sidekiq::Web::DEV_MODE
 
   ::Sidekiq::Web.use Rack::Static, urls: ["/batches_assets"],
                                    root: File.expand_path("#{File.dirname(__FILE__)}/web"),
                                    cascade: true,
                                    header_rules: rules
 
-  ::Sidekiq::Web.register CanvasSync::JobBatches::Sidekiq::Web
+  ::Sidekiq::Web.register CanvasSync::JobBatches::Compat::Sidekiq::Web
   ::Sidekiq::Web.tabs["Batches"] = "batches"
   ::Sidekiq::Web.tabs["Pools"] = "pools"
   ::Sidekiq::Web.settings.locales << File.join(File.dirname(__FILE__), "locales")

data/lib/canvas_sync/job_batches/{sidekiq.rb → compat/sidekiq.rb}

@@ -3,8 +3,8 @@ begin
 rescue LoadError
 end
 
-module CanvasSync
-  module JobBatches
+module CanvasSync::JobBatches
+  module Compat
     module Sidekiq
       module WorkerExtension
         def bid
@@ -41,6 +41,8 @@ module CanvasSync
       end
 
       class ClientMiddleware
+        include ::Sidekiq::ClientMiddleware if defined? ::Sidekiq::ClientMiddleware
+
         def call(_worker, msg, _queue, _redis_pool = nil)
           if (batch = Thread.current[CURRENT_BATCH_THREAD_KEY]) && should_handle_batch?(msg)
             batch.increment_job_queue(msg['jid']) if (msg[:bid] = batch.bid)
@@ -49,12 +51,14 @@ module CanvasSync
         end
 
         def should_handle_batch?(msg)
-          return false if JobBatches::Sidekiq.is_activejob_job?(msg)
+          return false if CanvasSync::JobBatches::Compat::Sidekiq.is_activejob_job?(msg)
           true
         end
       end
 
       class ServerMiddleware
+        include ::Sidekiq::ServerMiddleware if defined? ::Sidekiq::ServerMiddleware
+
         def call(_worker, msg, _queue)
           if (bid = msg['bid'])
             prev_batch = Thread.current[CURRENT_BATCH_THREAD_KEY]
@@ -78,7 +82,7 @@ module CanvasSync
       def self.is_activejob_job?(msg)
         return false unless defined?(::ActiveJob)
 
-        msg['class'] == 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper' && (msg['wrapped'].to_s).constantize < JobBatches::ActiveJob::BatchAwareJob
+        msg['class'] == 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper' && (msg['wrapped'].to_s).constantize < CanvasSync::JobBatches::Compat::ActiveJob::BatchAwareJob
       end
 
       def self.switch_tenant(job)
@@ -91,42 +95,51 @@ module CanvasSync
         end
       end
 
+      def self.sidekiq_middleware(placement, &blk)
+        install_middleware = ->(config) do
+          config.send("#{placement}_middleware") do |chain|
+            blk.call(chain)
+          end
+        end
+
+        ::Sidekiq.configure_client(&install_middleware) if placement == :client
+        ::Sidekiq.configure_server(&install_middleware)
+      end
+
       def self.configure
-        if defined?(::Sidekiq::Batch) && ::Sidekiq::Batch != JobBatches::Batch
+        return if @already_configured
+        @already_configured = true
+
+        if defined?(::Sidekiq::Batch) && ::Sidekiq::Batch != CanvasSync::JobBatches::Batch
           print "WARNING: Detected Sidekiq Pro or sidekiq-batch. CanvasSync JobBatches may not be fully compatible!"
         end
 
-        ::Sidekiq.configure_client do |config|
-          config.client_middleware do |chain|
-            chain.remove ::Sidekiq::Batch::Middleware::ClientMiddleware if defined?(::Sidekiq::Batch::Middleware::ClientMiddleware)
-            chain.add JobBatches::Sidekiq::ClientMiddleware
-          end
+        sidekiq_middleware(:client) do |chain|
+          chain.remove ::Sidekiq::Batch::Middleware::ClientMiddleware if defined?(::Sidekiq::Batch::Middleware::ClientMiddleware)
+          chain.add CanvasSync::JobBatches::Compat::Sidekiq::ClientMiddleware
         end
-        ::Sidekiq.configure_server do |config|
-          config.client_middleware do |chain|
-            chain.remove ::Sidekiq::Batch::Middleware::ClientMiddleware if defined?(::Sidekiq::Batch::Middleware::ClientMiddleware)
-            chain.add JobBatches::Sidekiq::ClientMiddleware
-          end
 
-          config.server_middleware do |chain|
-            chain.remove ::Sidekiq::Batch::Middleware::ServerMiddleware if defined?(::Sidekiq::Batch::Middleware::ServerMiddleware)
-            chain.add JobBatches::Sidekiq::ServerMiddleware
-          end
+        sidekiq_middleware(:server) do |chain|
+          chain.remove ::Sidekiq::Batch::Middleware::ServerMiddleware if defined?(::Sidekiq::Batch::Middleware::ServerMiddleware)
+          chain.add CanvasSync::JobBatches::Compat::Sidekiq::ServerMiddleware
+        end
 
+        ::Sidekiq.configure_server do |config|
           config.death_handlers << ->(job, ex) do
             switch_tenant(job) do
               if is_activejob_job?(job)
-                JobBatches::ActiveJob.handle_job_death(job["args"][0], ex)
+                CanvasSync::JobBatches::Compat::ActiveJob.handle_job_death(job["args"][0], ex)
               elsif job['bid'].present?
                 ::Sidekiq::Batch.process_dead_job(job['bid'], job['jid'])
               end
             end
           end
         end
+
         ::Sidekiq.const_set(:Batch, CanvasSync::JobBatches::Batch)
         # This alias helps apartment-sidekiq set itself up correctly
-        ::Sidekiq::Batch.const_set(:Server, CanvasSync::JobBatches::Sidekiq::ServerMiddleware)
-        ::Sidekiq::Worker.send(:include, JobBatches::Sidekiq::WorkerExtension)
+        ::Sidekiq::Batch.const_set(:Server, CanvasSync::JobBatches::Compat::Sidekiq::ServerMiddleware)
+        ::Sidekiq::Worker.send(:include, CanvasSync::JobBatches::Compat::Sidekiq::WorkerExtension)
         Batch::Callback.worker_class = SidekiqCallbackWorker
       end
     end

data/lib/canvas_sync/job_batches/compat.rb

@@ -0,0 +1,20 @@
+
+module CanvasSync::JobBatches
+  module Compat
+    def self.load_compat(name)
+      name = name.to_s
+      begin
+        require name
+      rescue LoadError
+      end
+
+      if name.classify.safe_constantize
+        require_relative "./compat/#{name}"
+        "CanvasSync::JobBatches::Compat::#{name.classify}".constantize.configure
+      end
+    end
+
+    load_compat(:active_job)
+    load_compat(:sidekiq)
+  end
+end