canvas_sync 0.16.4 → 0.21.0

data/lib/canvas_sync/jobs/begin_sync_chain_job.rb

@@ -0,0 +1,99 @@
+module CanvasSync
+  module Jobs
+    class BeginSyncChainJob < CanvasSync::Job
+      attr_reader :globals
+
+      def perform(chain_definition, globals = {})
+        @globals = globals
+
+        if globals[:updated_after] == nil && Rails.env.development?
+          globals[:updated_after] = false
+        end
+
+        if globals[:updated_after] == false
+          globals[:updated_after] = nil
+        elsif !globals[:updated_after].present? || globals[:updated_after] == true
+          last_batch = SyncBatch.where(status: 'completed', batch_genre: genre).last
+          globals[:full_sync_every] ||= "sunday/2"
+          globals[:updated_after] = ((last_batch.started_at - 1.day).iso8601 rescue nil)
+        end
+
+        # Refuse to run syncs of the same genre if there is a running full sync
+        if last_full_sync_record&.status == 'processing' && last_full_sync > 12.hours.ago
+          Rails.logger.warn("Attempted to start a '#{genre}' sync while a full-sync is still processing.")
+          return
+        end
+
+        if should_full_sync?(globals[:full_sync_every])
+          globals[:updated_after] = nil
+        end
+
+        sync_batch = SyncBatch.create!(
+          started_at: DateTime.now,
+          full_sync: globals[:updated_after] == nil,
+          batch_genre: genre,
+          status: 'processing',
+        )
+
+        globals[:batch_genre] = genre
+        globals[:batch_start_time] = sync_batch.started_at.iso8601
+        globals[:sync_batch_id] = sync_batch.id
+
+        JobBatches::Batch.new.tap do |b|
+          b.description = "CanvasSync Root Batch (SyncBatch##{sync_batch.id})"
+          b.on(:complete, "#{self.class.to_s}.batch_completed", sync_batch_id: sync_batch.id)
+          b.on(:success, "#{self.class.to_s}.batch_completed", sync_batch_id: sync_batch.id)
+          b.context = globals
+          b.jobs do
+            JobBatches::SerialBatchJob.perform_now(chain_definition)
+          end
+          sync_batch.update(batch_bid: b.bid)
+        end
+      end
+
+      def should_full_sync?(opt)
+        return true unless last_full_sync.present?
+        return false unless opt.is_a?(String)
+
+        case opt.strip
+        when %r{^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)(?:/(\d+))?$}
+          m = Regexp.last_match
+          day = m[1]
+          skip = m[2] || "1"
+          DateTime.now.send(:"#{day}?") && last_full_sync.end_of_day <= (skip.to_i.weeks.ago.end_of_day)
+        when %r{^(\d+)\%$}
+          m = Regexp.last_match
+          rand(100) < m[1].to_i
+        when %r{^(\d+) ?days$}
+          m = Regexp.last_match
+          last_full_sync.end_of_day <= m[1].to_i.days.ago.end_of_day
+        when %r{^(\d+)$} # N.days is converted to a string of seconds
+          m = Regexp.last_match
+          last_full_sync.end_of_day <= m[1].to_i.seconds.ago.end_of_day
+        else
+          false
+        end
+      end
+
+      def last_full_sync_record
+        @last_full_sync_record ||= SyncBatch.where(status: ['completed', 'processing'], full_sync: true, batch_genre: genre).last
+      end
+
+      def last_full_sync
+        last_full_sync_record&.started_at
+      end
+
+      def genre
+        globals[:batch_genre] || "default"
+      end
+
+      def self.batch_completed(status, options)
+        sbatch = SyncBatch.find(options['sync_batch_id'])
+        sbatch.update!(
+          status: status.success? ? 'completed' : 'failed',
+          completed_at: DateTime.now,
+        )
+      end
+    end
+  end
+end

data/lib/canvas_sync/jobs/canvas_process_waiter.rb

@@ -0,0 +1,41 @@
+module CanvasSync::Jobs
+  class CanvasProcessWaiter < ActiveJob::Base
+    # rubocop:disable Metrics/PerceivedComplexity
+    def perform(progress_url, next_job, kwargs = {})
+      kwargs = kwargs.symbolize_keys
+
+      response = canvas_sync_client.get(progress_url)
+      status = kwargs[:status_key].present? ? response[kwargs[:status_key]] : response['workflow_state'] || response['status']
+
+      if %w[completed complete imported imported_with_messages].include? status
+        InvokeCallbackWorker.perform_later(build_next_job(next_job, kwargs, response)) if next_job
+      elsif %w[failed error failed_with_messages].include? status
+        if kwargs[:on_failure].is_a?(Hash)
+          InvokeCallbackWorker.perform_later(build_next_job(kwargs[:on_failure], kwargs, response))
+        else
+          Rails.logger.error("Progress #{progress_url} failed")
+        end
+      else # if status == 'queued' || status == 'running'
+        interval = kwargs[:interval] || (Rails.env.development? ? 3 : 60)
+        CanvasProcessWaiter.set(wait: interval).perform_later(progress_url, next_job, kwargs)
+      end
+    end
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    def build_next_job(job, kwargs, response)
+      job = job.symbolize_keys
+      if kwargs[:progress_as].present?
+        job[:kwargs] ||= {}
+        job[:kwargs][kwargs[:progress_as].to_sym] = response
+      end
+      job
+    end
+
+    # This is a separate job so that, if it fails and a retry is triggered, it doesn't query the API needlessly
+    class InvokeCallbackWorker < ActiveJob::Base
+      def perform(job)
+        CanvasSync::MiscHelper.invoke_task(job)
+      end
+    end
+  end
+end

data/lib/canvas_sync/jobs/report_checker.rb

@@ -4,21 +4,28 @@ module CanvasSync
     # Re-enqueues itself if the report is still processing on Canvas.
     # Enqueues the ReportProcessor when the report has completed.
     class ReportChecker < CanvasSync::Job
-      # @param job_chain [Hash]
+      REPORT_TIMEOUT = 24.hours
+      COMPILATION_TIMEOUT = 3.hours
+      MAX_TRIES = 3
+
+      class FatalReportError < ::RuntimeError; end
+
+      discard_on FatalReportError
+
       # @param report_name [Hash] e.g., 'provisioning_csv'
       # @param report_id [Integer]
       # @param processor [String] a stringified report processor class name
       # @param options [Hash] hash of options that will be passed to the job processor
       # @return [nil]
-      def perform(job_chain, report_name, report_id, processor, options) # rubocop:disable Metrics/AbcSize
-        account_id = options[:account_id] || job_chain[:global_options][:account_id] || "self"
-        report_status = CanvasSync.get_canvas_sync_client(job_chain[:global_options])
+      def perform(report_name, report_id, processor, options, checker_context = {}) # rubocop:disable Metrics/AbcSize
+        max_tries = options[:report_max_tries] || batch_context[:report_max_tries] || MAX_TRIES
+        account_id = options[:account_id] || batch_context[:account_id] || "self"
+        report_status = CanvasSync.get_canvas_sync_client(batch_context)
                                   .report_status(account_id, report_name, report_id)
 
         case report_status["status"].downcase
         when "complete"
           CanvasSync::Jobs::ReportProcessorJob.perform_later(
-            job_chain,
             report_name,
             report_status["attachment"]["url"],
             processor,
@@ -26,21 +33,76 @@ module CanvasSync
             report_id,
           )
         when "error", "deleted"
-          message = "Report failed to process; status was #{report_status} for report_name: #{report_name}, report_id: #{report_id}" # rubocop:disable Metrics/LineLength
+          checker_context[:failed_attempts] ||= 0
+          checker_context[:failed_attempts] += 1
+          failed_attempts = checker_context[:failed_attempts]
+          message = "Report failed to process; status was #{report_status} for report_name: #{report_name}, report_id: #{report_id}, #{current_organization.name}.  This report has now failed #{checker_context[:failed_attempts]} time." # rubocop:disable Metrics/LineLength
           Rails.logger.error(message)
-          raise message
+          if failed_attempts >= max_tries
+            Rails.logger.error("This report has failed #{failed_attempts} times.  Giving up.")
+            raise FatalReportError, message
+          else
+            restart_report(options, report_name, processor, checker_context)
+          end
         else
+          report_timeout = parse_timeout(options[:report_timeout] || batch_context[:report_timeout] || REPORT_TIMEOUT)
+          if timeout_met?(options[:sync_start_time], report_timeout)
+            raise FatalReportError, "Report appears to be stuck #{report_name}##{report_id}"
+          end
+
+          if report_status["status"].downcase == 'compiling'
+            checker_context['compiling_since'] ||= DateTime.now.iso8601
+            compilation_timeout = parse_timeout(options[:report_compilation_timeout] || batch_context[:report_compilation_timeout] || COMPILATION_TIMEOUT)
+            if timeout_met?(checker_context['compiling_since'], compilation_timeout)
+              raise FatalReportError, "Report appears to be stuck #{report_name}##{report_id}"
+            end
+          end
+
           CanvasSync::Jobs::ReportChecker
             .set(wait: report_checker_wait_time)
             .perform_later(
-              job_chain,
               report_name,
               report_id,
               processor,
               options,
+              checker_context
             )
         end
       end
+
+      protected
+
+      def timeout_met?(base_time, timeout_length)
+        return false unless base_time.present? && timeout_length.present?
+        DateTime.now > (DateTime.parse(base_time) + timeout_length)
+      end
+
+      def parse_timeout(val)
+        val
+      end
+
+      def restart_report(options, report_name, processor, checker_context)
+        account_id = options[:account_id] || batch_context[:account_id] || "self"
+        options[:sync_start_time] = DateTime.now.utc.iso8601
+        new_context = {}
+        new_context[:failed_attempts] = checker_context[:failed_attempts]
+        report_id = start_report(account_id, report_name, options[:report_params])
+        CanvasSync::Jobs::ReportChecker
+            .set(wait: report_checker_wait_time)
+            .perform_later(
+              report_name,
+              report_id,
+              processor,
+              options,
+              new_context
+            )
+      end
+
+      def start_report(account_id, report_name, report_params)
+        report = CanvasSync.get_canvas_sync_client(batch_context)
+                           .start_report(account_id, report_name, report_params)
+        report["id"]
+      end
     end
   end
 end

data/lib/canvas_sync/jobs/report_processor_job.rb

@@ -6,22 +6,19 @@ module CanvasSync
     # download the report, and then pass the file path and options into the
     # process method on the processor.
     class ReportProcessorJob < CanvasSync::Job
-      # @param job_chain [Hash]
       # @param report_name [Hash] e.g., 'provisioning_csv'
       # @param report_url [String]
       # @param processor [String] a stringified report processor class name
       # @param options [Hash] hash of options that will be passed to the job processor
       # @return [nil]
-      def perform(job_chain, report_name, report_url, processor, options, report_id)
-        @job_log.update_attributes(job_class: processor)
+      def perform(report_name, report_url, processor, options, report_id)
+        @job_log.update(job_class: processor)
         download(report_name, report_url) do |file_path|
-          options = job_chain[:global_options].merge(options).merge({
+          options = batch_context.merge(options).merge({
             report_processor_job_id: @job_log.job_id
           })
           processor.constantize.process(file_path, options, report_id)
         end
-
-        CanvasSync.invoke_next(job_chain)
       end
 
       private
@@ -29,7 +26,7 @@ module CanvasSync
       def download(report_name, report_url)
         Dir.mktmpdir do |dir|
           file_path = "#{dir}/#{report_name}"
-          IO.copy_stream(open(report_url), file_path)
+          IO.copy_stream(URI.open(report_url), file_path)
           yield file_path
         end
       end

data/lib/canvas_sync/jobs/report_starter.rb

@@ -2,7 +2,6 @@ module CanvasSync
   module Jobs
     # Starts a Canvas report and enqueues a ReportChecker
     class ReportStarter < CanvasSync::Job
-      # @param job_chain [Hash]
       # @param report_name [Hash] e.g., 'provisioning_csv'
       # @param report_params [Hash] The Canvas report parameters
       # @param processor [String] a stringified report processor class name
@@ -10,38 +9,53 @@ module CanvasSync
       # @param allow_redownloads [Boolean] whether you want the job_chain to cache this report,
       #   so that any later jobs in the chain will use the same generated report
       # @return [nil]
-      def perform(job_chain, report_name, report_params, processor, options, allow_redownloads: false)
-        account_id = options[:account_id] || job_chain[:global_options][:account_id] || "self"
+      def perform(report_name, report_params, processor, options, allow_redownloads: false)
+        account_id = options[:account_id] || batch_context[:account_id] || "self"
+        options[:sync_start_time] = DateTime.now.utc.iso8601
+        options[:report_params] = report_params
+        report_id = start_report(account_id, report_name, report_params)
+        # TODO: Restore report caching support (does nayone actually use it?)
+        # report_id = if allow_redownloads
+        #               get_cached_report(account_id, report_name, report_params)
+        #             else
+        #               start_report(account_id, report_name, report_params)
+        #             end
 
-        report_id = if allow_redownloads
-                      get_cached_report(job_chain, account_id, report_name, report_params)
-                    else
-                      start_report(job_chain, account_id, report_name, report_params)
-                    end
-
-        CanvasSync::Jobs::ReportChecker.set(wait: report_checker_wait_time).perform_later(
-          job_chain,
-          report_name,
-          report_id,
-          processor,
-          options,
-        )
+        batch = JobBatches::Batch.new
+        batch.description = "CanvasSync #{report_name} Fiber"
+        batch.jobs do
+          CanvasSync::Jobs::ReportChecker.set(wait: report_checker_wait_time).perform_later(
+            report_name,
+            report_id,
+            processor.to_s,
+            options
+          )
+        end
       end
 
       protected
 
-      def merge_report_params(job_chain, options={}, params={}, term_scope: true)
-        term_scope = job_chain[:global_options][:canvas_term_id] if term_scope == true
+      # Ruby 3 changed how kwargs are handled. _kw_placeholder allows for backwards compatibility
+      # In Ruby 2, merge_report_params(options, params) would parse as merge_report_params(options, params={}, **params) (wtf?), so
+      # merge_report_params(options, params, {}) is used. That doesn't work in Ruby 3.
+      # In order to maintain compatibility with 2 and with any apps, this oddness is needed
+      def merge_report_params(options, params={}, _kw_placeholder=nil, term_scope: true)
+        term_scope = options[:canvas_term_id] || batch_context[:canvas_term_id] if term_scope == true
         if term_scope.present?
           params[:enrollment_term_id] = term_scope
         end
+        if (updated_after = batch_context[:updated_after]).present?
+          params[:updated_after] = updated_after
+        end
         params.merge!(options[:report_params]) if options[:report_params].present?
+        params.merge!(options[:report_parameters]) if options[:report_parameters].present?
         { parameters: params }
       end
 
       private
 
       def get_cached_report(job_chain, account_id, report_name, report_params)
+        # TODO: job_chain[:global_options] is no longer available and batch_context won't work for this
         if job_chain[:global_options][report_name].present?
           job_chain[:global_options][report_name]
         else
@@ -51,8 +65,8 @@ module CanvasSync
         end
       end
 
-      def start_report(job_chain, account_id, report_name, report_params)
-        report = CanvasSync.get_canvas_sync_client(job_chain[:global_options])
+      def start_report(account_id, report_name, report_params)
+        report = CanvasSync.get_canvas_sync_client(batch_context)
                            .start_report(account_id, report_name, report_params)
         report["id"]
       end

data/lib/canvas_sync/jobs/sync_accounts_job.rb

@@ -7,18 +7,16 @@ module CanvasSync
       # running provisioning by term we sync users first so we don't duplicate
       # the work of syncing all accounts for each term.
       #
-      # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, options)
+      def perform(options)
         unless options[:root_account] == false
-          acc_params = CanvasSync.get_canvas_sync_client(job_chain[:global_options]).account("self")
+          acc_params = CanvasSync.get_canvas_sync_client(batch_context).account("self")
           update_or_create_model(Account, acc_params)
         end
 
         super(
-          job_chain,
           "proservices_provisioning_csv",
-          merge_report_params(job_chain, options, {
+          merge_report_params(options, {
             accounts: true,
             include_deleted: true,
           }, term_scope: false),

data/lib/canvas_sync/jobs/sync_admins_job.rb

@@ -4,11 +4,10 @@ module CanvasSync
       # Syncs Admins using the Canvas API
       #
       #
-      # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, _options)
+      def perform(options)
         updated_admin_ids = []
-        api_client = CanvasSync.get_canvas_sync_client(job_chain[:global_options])
+        api_client = CanvasSync.get_canvas_sync_client(batch_context)
         CanvasSync.sync_scope(Account).find_each do |acc|
           api_client.account_admins(acc.canvas_id).all_pages_each do |admin_params|
             admin_params[:account_id] = acc.canvas_id
@@ -17,7 +16,6 @@ module CanvasSync
           end
         end
         Admin.where.not(id: updated_admin_ids).update_all(workflow_state: 'inactive')
-        CanvasSync.invoke_next(job_chain)
       end
     end
   end

data/lib/canvas_sync/jobs/sync_assignment_groups_job.rb

@@ -6,13 +6,11 @@ module CanvasSync
       # Starts a report processor for the assignment_groups report
       # (the proserv_assignment_group_export_csv report must be enabled)
       #
-      # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, options)
+      def perform(options)
         super(
-          job_chain,
           "proserv_assignment_group_export_csv",
-          merge_report_params(job_chain, options),
+          merge_report_params(options),
           CanvasSync::Processors::AssignmentGroupsProcessor.to_s,
           {},
         )

data/lib/canvas_sync/jobs/sync_assignments_job.rb

@@ -6,13 +6,11 @@ module CanvasSync
       # Starts a report processor for the assignment report
       # (the proserv_assignment_export_csv report must be enabled)
       #
-      # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, options)
+      def perform(options)
         super(
-          job_chain,
           "proserv_assignment_export_csv",
-          merge_report_params(job_chain, options),
+          merge_report_params(options),
           CanvasSync::Processors::AssignmentsProcessor.to_s,
           {},
         )

data/lib/canvas_sync/jobs/sync_content_migrations_job.rb

@@ -0,0 +1,20 @@
+module CanvasSync
+  module Jobs
+    class SyncContentMigrationsJob < ReportStarter
+      # Syncs ContentMigrations
+      #
+      # Starts a report processor for the content migrations report
+      # (the proserv_content_migrations_csv report must be enabled)
+      #
+      # @param options [Hash]
+      def perform(options)
+        super(
+          "proserv_content_migrations_csv",
+          merge_report_params(options),
+          CanvasSync::Processors::ContentMigrationsProcessor.to_s,
+          {},
+        )
+      end
+    end
+  end
+end

data/lib/canvas_sync/jobs/sync_context_module_items_job.rb

@@ -6,13 +6,11 @@ module CanvasSync
       # Starts a report processor for the context modules report
       # (the proserv_context_module_items_csv report must be enabled)
       #
-      # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, options)
+      def perform(options)
         super(
-          job_chain,
           "proserv_context_module_items_csv",
-          merge_report_params(job_chain, options),
+          merge_report_params(options),
           CanvasSync::Processors::ContextModuleItemsProcessor.to_s,
           {},
         )

data/lib/canvas_sync/jobs/sync_context_modules_job.rb

@@ -6,13 +6,11 @@ module CanvasSync
       # Starts a report processor for the context modules report
       # (the proserv_context_modules_csv report must be enabled)
       #
-      # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, options)
+      def perform(options)
         super(
-          job_chain,
           "proserv_context_modules_csv",
-          merge_report_params(job_chain, options),
+          merge_report_params(options),
           CanvasSync::Processors::ContextModulesProcessor.to_s,
           {},
         )

data/lib/canvas_sync/jobs/sync_provisioning_report_job.rb

@@ -1,49 +1,8 @@
 module CanvasSync
   module Jobs
     # ActiveJob class that starts a Canvas provisioning report
-    class SyncProvisioningReportJob < CanvasSync::Job
-      # @param job_chain [Hash]
-      # @param options [Hash] If options contains a :term_scope a seperate provisioning report
-      #   will be started for each term in that scope. :models should be an array of
-      #   models to sync.
-      def perform(job_chain, options)
-        if options[:term_scope]
-          sub_reports = CanvasSync.fork(@job_log, job_chain, keys: [:canvas_term_id]) do |job_chain|
-            Term.send(options[:term_scope]).find_each.map do |term|
-              # Deep copy the job_chain so each report gets the correct term id passed into
-              # its options with no side effects
-              term_id = get_term_id(term)
-              duped_job_chain = Marshal.load(Marshal.dump(job_chain))
-              duped_job_chain[:global_options][:canvas_term_id] = term_id
-              {
-                job_chain: duped_job_chain,
-                params: report_params(options, term_id),
-                options: options,
-              }
-            end
-          end
-
-          sub_reports.each do |r|
-            start_report(r[:params], r[:job_chain], r[:options])
-          end
-        else
-          start_report(report_params(options), job_chain, options)
-        end
-      end
-
-      protected
-
-      def start_report(report_params, job_chain, options)
-        CanvasSync::Jobs::ReportStarter.perform_later(
-          job_chain,
-          "proservices_provisioning_csv",
-          report_params,
-          CanvasSync::Processors::ProvisioningReportProcessor.to_s,
-          options,
-        )
-      end
-
-      def report_params(options, canvas_term_id=nil)
+    class SyncProvisioningReportJob < ReportStarter
+      def perform(options)
         params = {
           include_deleted: true,
         }
@@ -51,18 +10,25 @@ module CanvasSync
         options[:models].each do |model|
           # group_membership is the only model param that is singular :(
           model = 'group_membership' if model == 'group_memberships'
+
           params[model] = true
         end
 
-        params[:enrollment_term_id] = canvas_term_id if canvas_term_id
+        merged_params = merge_report_params(options, params, {}).with_indifferent_access
 
-        params.merge!(options[:report_parameters]) if options[:report_parameters].present?
-
-        { parameters: params }
-      end
+        # Make sure the report also checks last_activity_at when checking updated_at
+        if options[:models].include?("enrollments")
+          if (%w[last_activity_at total_activity_time] & CanvasSync::Concerns::SyncMapping.mapping_for(Enrollment)[:columns].keys).present? && merged_params.dig(:parameters, :include_last_activity) == nil
+            merged_params[:parameters][:include_last_activity] = true
+          end
+        end
 
-      def get_term_id(term)
-        term.try(:canvas_id) || term.canvas_term_id
+        super(
+          "proservices_provisioning_csv",
+          merged_params,
+          CanvasSync::Processors::ProvisioningReportProcessor.to_s,
+          options,
+        )
       end
     end
   end

data/lib/canvas_sync/jobs/sync_roles_job.rb

@@ -3,12 +3,10 @@ module CanvasSync
     class SyncRolesJob < CanvasSync::Job
       # Syncs Roles using the Canvas API
       #
-      #
-      # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, _options)
+      def perform(options)
         updated_role_ids = []
-        api_client = CanvasSync.get_canvas_sync_client(job_chain[:global_options])
+        api_client = CanvasSync.get_canvas_sync_client(batch_context)
         CanvasSync.sync_scope(Account).find_each do |acc|
           api_client.list_roles(acc.canvas_id, state: %w[active inactive]).all_pages_each do |role_params|
             role = update_or_create_model(Role, role_params)
@@ -16,7 +14,6 @@ module CanvasSync
           end
         end
         Role.where.not(id: updated_role_ids).update_all(workflow_state: 'inactive')
-        CanvasSync.invoke_next(job_chain)
       end
     end
   end

data/lib/canvas_sync/jobs/sync_rubric_assessments_job.rb

@@ -0,0 +1,15 @@
+module CanvasSync
+  module Jobs
+    class SyncRubricAssessmentsJob < ReportStarter
+      # @param options [Hash]
+      def perform(options)
+        super(
+          "rubric_assessments_csv",
+          merge_report_params(options),
+          CanvasSync::Processors::RubricAssessmentsProcessor.to_s,
+          {},
+        )
+      end
+    end
+  end
+end

data/lib/canvas_sync/jobs/sync_rubric_associations_job.rb

@@ -0,0 +1,15 @@
+module CanvasSync
+  module Jobs
+    class SyncRubricAssociationsJob < ReportStarter
+      # @param options [Hash]
+      def perform(options)
+        super(
+          "rubric_associations_csv",
+          merge_report_params(options),
+          CanvasSync::Processors::RubricAssociationsProcessor.to_s,
+          {},
+        )
+      end
+    end
+  end
+end