canvas_sync 0.17.40 → 0.17.42

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 252aa98d20ca9456416bab466fdbfc5bcfe5d7626a8462002a66034c5aa8e168
-  data.tar.gz: da8257b9f54f1840b19661982a712c51a2e720e5defecdd2080b1ecd3d2962f7
+  metadata.gz: 6637b97dd9b51f6d3babe9b022904d9e77b1c886e62707fb857db5caba909fc3
+  data.tar.gz: 1bfa80e171b9b92b12ebad2fdc732b558e59fe9271175ce7d1dd2680a81e2b0c
 SHA512:
-  metadata.gz: 247383e570fe4b9f89640bfee466ba616bd845e299c03fef240e14c45fbc9d2cd5558d3ea09bc8a80bb8d8a6d451ed7f6fa5f162ef93d0764f3e4fb9ea022c62
-  data.tar.gz: d470874db2a8008a5be3bafbae07161fd79ec931eb7c98414fd233bccb4778bb5a4054337aa2c677c00a5e51c17e13dd69a7eb6759c2e30f817bac7817318ed7
+  metadata.gz: 0af624f526294b480e6b24814ab9156f3970056160eb59e0aafdd9af2849984ef34668099cce16f978257b6311c5fbfe69e2fe9e0bfd52224034c7e8018afbfc
+  data.tar.gz: 2d2d89dc832f3cb4d901641f00c930f929ca410f86b2890689909f43fea3fb29d56584fa72c5871382101d946ff7d50fde3d044375ae03d1b8de230bba13788b

data/lib/canvas_sync/concerns/sync_mapping.rb

@@ -28,7 +28,7 @@ module CanvasSync::Concerns
         @model = model
         @map_def = map_def
         @map_def[:conflict_target] ||= []
-        @map_def[:report_columns] ||= {}
+        @map_def[:columns] ||= {}
       end
 
       def self.normalize_model_name(model)
@@ -50,9 +50,9 @@ module CanvasSync::Concerns
               legacy[:report_columns][lct][:database_column_name]
             end
 
-            m[:report_columns] = {}
+            m[:columns] = {}
             legacy[:report_columns].each do |rcol, opts|
-              m[:report_columns][opts[:database_column_name]] = opts.except(:database_column_name).merge!(
+              m[:columns][opts[:database_column_name]] = opts.except(:database_column_name).merge!(
                 report_column: rcol,
               ).freeze
             end
@@ -84,23 +84,23 @@ module CanvasSync::Concerns
       end
 
       def reset_links
-        @map_def[:report_columns] = {}.with_indifferent_access
+        @map_def[:columns] = {}.with_indifferent_access
       end
 
       def unlink_column(key)
-        @map_def[:report_columns].delete(key)
+        @map_def[:columns].delete(key)
       end
 
       def link_column(m, type: nil, &blk)
         if m.is_a?(Hash)
           raise "Hash should have exactly 1 entry" if m && m.count != 1
-          @map_def[:report_columns][m.values[0]] = {
+          @map_def[:columns][m.values[0]] = {
             report_column: m.keys[0],
             type: type,
             transform: blk,
           }
         elsif m.is_a?(Symbol)
-          @map_def[:report_columns][m] = {
+          @map_def[:columns][m] = {
             report_column: m,
             type: type,
             transform: blk,

data/lib/canvas_sync/engine.rb

@@ -5,9 +5,10 @@ module CanvasSync
   class Engine < ::Rails::Engine
     isolate_namespace CanvasSync
 
-    initializer "canvas_sync.serialze_symbols" do |app|
+    initializer "canvas_sync.safe_yaml_classes" do |app|
       app.config.active_record.yaml_column_permitted_classes ||= []
-      app.config.active_record.yaml_column_permitted_classes |= [Symbol]
+      app.config.active_record.yaml_column_permitted_classes |= [Symbol, ActiveSupport::HashWithIndifferentAccess]
+      ActiveRecord::Base.yaml_column_permitted_classes |= app.config.active_record.yaml_column_permitted_classes
     rescue
     end
 
@@ -40,12 +41,14 @@ module CanvasSync
 
       require 'panda_pal'
 
-      def canvas_sync_client(account_id = nil)
-        Bearcat::Client.new(
-          prefix: current_organization.canvas_url,
-          token: current_organization.canvas_api_token,
-          master_rate_limit: (Rails.env.production? && !!defined?(Redis) && ENV['REDIS_URL'].present?),
-        )
+      class ::Object
+        def canvas_sync_client(account_id = nil)
+          Bearcat::Client.new(
+            prefix: current_organization.canvas_url,
+            token: current_organization.canvas_api_token,
+            master_rate_limit: (Rails.env.production? && !!defined?(Redis) && ENV['REDIS_URL'].present?),
+          )
+        end
       end
     rescue LoadError
     end

data/lib/canvas_sync/job_batches/batch.rb

@@ -157,13 +157,13 @@ module CanvasSync
             let_close!
           end
         else
-          redis.hset(@bidkey, 'keep_open', true)
+          redis.hset(@bidkey, 'keep_open', "true")
         end
       end
 
       def let_close!
         _, failed, pending, children, complete, success = redis.multi do |r|
-          r.hset(@bidkey, 'keep_open', false)
+          r.hset(@bidkey, 'keep_open', "false")
 
           r.scard("BID-#{bid}-failed")
           r.hincrby("BID-#{bid}", "pending", 0)
@@ -333,7 +333,7 @@ module CanvasSync
           opts = {"bid" => bid, "event" => event}
           should_schedule_batch = callback_args.present? && !callback_params.present?
           already_processed = redis do |r|
-            SCHEDULE_CALLBACK.call(r, [batch_key], [event.to_s, should_schedule_batch, BID_EXPIRE_TTL])
+            SCHEDULE_CALLBACK.call(r, [batch_key], [event.to_s, should_schedule_batch.to_s, BID_EXPIRE_TTL])
           end
 
           return if already_processed == 'true'

data/lib/canvas_sync/jobs/begin_sync_chain_job.rb

@@ -6,6 +6,10 @@ module CanvasSync
       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

data/lib/canvas_sync/jobs/canvas_process_waiter.rb

@@ -0,0 +1,73 @@
+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].include? status
+        InvokeCallbackWorker.perform_later(build_next_job(next_job, kwargs, response)) if next_job
+      elsif %w[failed error].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
+      # rubocop:disable Metrics/PerceivedComplexity
+      def perform(job)
+        job = job.symbolize_keys
+
+        params = job[:args] || []
+        params << job[:kwargs].symbolize_keys if job[:kwargs]
+        # params[-1] = params[-1].symbolize_keys if params[-1].is_a?(Hash)
+
+        if job[:model]
+          model_class = load_constant(job[:model])
+          find_by = job[:find_by]
+          target = find_by.is_a?(Hash) ? model_class.find_by(find_by) : model_class.find_by(id: find_by)
+          target.send(job[:method], *params)
+        elsif job[:class]
+          target = load_constant(job[:class])
+          target.send(job[:method], *params)
+        elsif job[:instance_of]
+          target = load_constant(job[:instance_of]).new
+          target.send(job[:method], *params)
+        elsif job[:job]
+          job_class = load_constant(job[:job])
+          job_class = job_class.set(job[:options]) if job[:options].present?
+          if job_class < ActiveJob::Base
+            job_class.perform_later(*params)
+          else
+            job_class.perform_async(*params)
+          end
+        end
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def load_constant(const)
+        const = const.constantize if const.is_a?(String)
+        const
+      end
+    end
+  end
+end

data/lib/canvas_sync/jobs/report_checker.rb

@@ -8,6 +8,10 @@ module CanvasSync
       COMPILATION_TIMEOUT = 1.hour
       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
@@ -36,21 +40,21 @@ module CanvasSync
           Rails.logger.error(message)
           if failed_attempts >= max_tries
             Rails.logger.error("This report has failed #{failed_attempts} times.  Giving up.")
-            raise message
+            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 "Report appears to be stuck #{report_name}##{report_id}"
+            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 "Report appears to be stuck #{report_name}##{report_id}"
+              raise FatalReportError, "Report appears to be stuck #{report_name}##{report_id}"
             end
           end
 

data/lib/canvas_sync/jobs/report_processor_job.rb

@@ -26,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

@@ -35,7 +35,11 @@ module CanvasSync
 
       protected
 
-      def merge_report_params(options, params={}, 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

data/lib/canvas_sync/jobs/sync_provisioning_report_job.rb

@@ -10,12 +10,22 @@ 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
 
+        merged_params = merge_report_params(options, params, {}).with_indifferent_access
+
+        # 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] & Enrollment.get_sync_mapping[:columns].keys).present? && merged_params.dig(:parameters, :include_last_activity) == nil
+            merged_params[:parameters][:include_last_activity] = true
+          end
+        end
+
         super(
           "proservices_provisioning_csv",
-          merge_report_params(options, params, {}),
+          merged_params,
           CanvasSync::Processors::ProvisioningReportProcessor.to_s,
           options,
         )

data/lib/canvas_sync/processors/normal_processor.rb

@@ -16,10 +16,9 @@ module CanvasSync
         m = mapping[options[:mapping].to_sym]
         CanvasSync::Importers::BulkImporter.import(
           report_file_path,
-          m[:report_columns],
+          m[:columns],
           options[:klass].constantize,
           m[:conflict_target],
-          import_args: options
         )
       end
     end

data/lib/canvas_sync/processors/report_processor.rb

@@ -16,7 +16,7 @@ module CanvasSync
         m = mapping_for(model, mapping_key)
         CanvasSync::Importers::BulkImporter.import(
           report_file_path,
-          m[:report_columns],
+          m[:columns],
           model,
           m[:conflict_target],
           import_args: options,

data/lib/canvas_sync/version.rb

@@ -1,3 +1,3 @@
 module CanvasSync
-  VERSION = "0.17.40".freeze
+  VERSION = "0.17.42".freeze
 end

data/spec/canvas_sync/jobs/canvas_process_waiter_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+RSpec.describe CanvasSync::Jobs::CanvasProcessWaiter do
+  let!(:worker) { CanvasSync::Jobs::CanvasProcessWaiter.new }
+
+  describe 'perform' do
+    it 'queues a InvokeCallbackWorker when complete' do
+      job = {
+        args: [1, 2],
+        kwargs: { progress: anything },
+      }
+      allow_any_instance_of(Bearcat::Client).to receive(:get).and_return('workflow_state' => 'completed')
+      expect(CanvasSync::Jobs::CanvasProcessWaiter::InvokeCallbackWorker).to receive(:perform_later).with(job)
+      worker.perform('/blah/', job)
+    end
+
+    it 'invokes the on_failure callback if failed' do
+      job = {
+        args: [1, 2],
+        kwargs: { progress: anything },
+      }
+      allow_any_instance_of(Bearcat::Client).to receive(:get).and_return('workflow_state' => 'failed')
+      expect(CanvasSync::Jobs::CanvasProcessWaiter::InvokeCallbackWorker).to receive(:perform_later).with(job)
+      worker.perform('/blah/', nil, on_failure: job)
+    end
+
+    it 're-enqueues if incomplete' do
+      ActiveJob::Base.queue_adapter = :test
+      allow_any_instance_of(Bearcat::Client).to receive(:get).and_return('workflow_state' => 'pending')
+      worker.perform('/blah/', nil, interval: 13)
+      expect(CanvasSync::Jobs::CanvasProcessWaiter).to have_been_enqueued.once.with('/blah/', nil, interval: 13)
+    end
+  end
+
+  describe 'InvokeCallbackWorker' do
+    let!(:worker) { CanvasSync::Jobs::CanvasProcessWaiter::InvokeCallbackWorker.new }
+
+    with_model :Model do
+      table
+      model do
+        def wait_callback(*args); end
+
+        def self.wait_callback(*args); end
+      end
+    end
+
+    class CPW_TestWorker
+      extend Sidekiq::Worker
+    end
+
+    it 'schedules a given job' do
+      expect(CPW_TestWorker).to receive(:perform_async)
+      worker.perform(
+        job: 'CPW_TestWorker',
+        args: [1, 2],
+      )
+    end
+
+    it 'invokes a model method' do
+      model = Model.create!
+      expect(Model).to receive(:find_by).with(id: model.id).and_return(model)
+      expect(model).to receive(:wait_callback).with(1, 2, a: 3, b: 4)
+      worker.perform(
+        model: Model.to_s,
+        find_by: { id: model.id },
+        method: :wait_callback,
+        args: [1, 2],
+        kwargs: { a: 3, b: 4 },
+      )
+    end
+
+    it 'invokes a class method' do
+      expect(Model).to receive(:wait_callback).with(1, 2, a: 3, b: 4)
+      worker.perform(
+        class: Model.to_s,
+        method: :wait_callback,
+        args: [1, 2],
+        kwargs: { a: 3, b: 4 },
+      )
+    end
+  end
+end

data/spec/dummy/log/development.log

@@ -2260,3 +2260,196 @@ Migrating to CreateUsers (20220926221926)
    (1.2ms)  COMMIT
    (0.2ms)  SELECT pg_advisory_unlock(1438354376499275445)
    (0.3ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" ORDER BY "schema_migrations"."version" ASC
+   (1.1ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" ORDER BY "schema_migrations"."version" ASC
+   (0.8ms)  SELECT "ar_internal_metadata"."value" FROM "ar_internal_metadata" WHERE "ar_internal_metadata"."key" = $1  [["key", "environment"]]
+   (0.2ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" ORDER BY "schema_migrations"."version" ASC
+   (0.2ms)  SELECT "ar_internal_metadata"."value" FROM "ar_internal_metadata" WHERE "ar_internal_metadata"."key" = $1  [["key", "environment"]]
+   (0.2ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" ORDER BY "schema_migrations"."version" ASC
+   (0.2ms)  SELECT "ar_internal_metadata"."value" FROM "ar_internal_metadata" WHERE "ar_internal_metadata"."key" = $1  [["key", "environment"]]
+   (48.4ms)  DROP DATABASE IF EXISTS "canvas_sync_development"
+   (49.8ms)  DROP DATABASE IF EXISTS "canvas_sync_test"
+   (133.7ms)  CREATE DATABASE "canvas_sync_development" ENCODING = 'unicode'
+   (105.4ms)  CREATE DATABASE "canvas_sync_test" ENCODING = 'unicode'
+   (11.6ms)  CREATE TABLE "schema_migrations" ("version" character varying NOT NULL PRIMARY KEY)
+   (8.8ms)  CREATE TABLE "ar_internal_metadata" ("key" character varying NOT NULL PRIMARY KEY, "value" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (0.1ms)  SELECT pg_try_advisory_lock(1438354376499275445)
+   (0.4ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" ORDER BY "schema_migrations"."version" ASC
+Migrating to CreateCanvasSyncJobLog (20170915210836)
+   (0.2ms)  BEGIN
+   (8.8ms)  CREATE TABLE "canvas_sync_job_logs" ("id" serial NOT NULL PRIMARY KEY, "started_at" timestamp, "completed_at" timestamp, "exception" character varying, "backtrace" text, "job_class" character varying, "status" character varying, "metadata" text, "job_arguments" text, "created_at" timestamp, "updated_at" timestamp)
+  ActiveRecord::SchemaMigration Create (0.5ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20170915210836"]]
+   (1.2ms)  COMMIT
+Migrating to AddJobIdToCanvasSyncJobLogs (20180725155729)
+   (0.2ms)  BEGIN
+   (0.4ms)  ALTER TABLE "canvas_sync_job_logs" ADD "job_id" character varying
+   (3.9ms)  CREATE  INDEX  "index_canvas_sync_job_logs_on_job_id" ON "canvas_sync_job_logs"  ("job_id")
+  ActiveRecord::SchemaMigration Create (0.5ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20180725155729"]]
+   (1.3ms)  COMMIT
+Migrating to CreateCourses (20190702203621)
+   (0.2ms)  BEGIN
+   (10.3ms)  CREATE TABLE "courses" ("id" bigserial primary key, "canvas_id" bigint NOT NULL, "sis_id" character varying, "course_code" character varying, "name" character varying, "workflow_state" character varying, "canvas_account_id" integer, "canvas_term_id" integer, "start_at" timestamp, "end_at" timestamp, "grading_standard_id" bigint, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (5.4ms)  CREATE UNIQUE INDEX  "index_courses_on_canvas_id" ON "courses"  ("canvas_id")
+  ActiveRecord::SchemaMigration Create (0.5ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20190702203621"]]
+   (1.2ms)  COMMIT
+Migrating to CreateAccounts (20190702203622)
+   (0.2ms)  BEGIN
+   (9.6ms)  CREATE TABLE "accounts" ("id" bigserial primary key, "canvas_id" bigint NOT NULL, "sis_id" character varying, "canvas_parent_account_id" bigint, "sis_parent_account_id" character varying, "name" character varying, "workflow_state" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (4.0ms)  CREATE UNIQUE INDEX  "index_accounts_on_canvas_id" ON "accounts"  ("canvas_id")
+  ActiveRecord::SchemaMigration Create (0.5ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20190702203622"]]
+   (1.3ms)  COMMIT
+Migrating to CreateTerms (20190702203623)
+   (0.3ms)  BEGIN
+   (8.1ms)  CREATE TABLE "terms" ("id" bigserial primary key, "canvas_id" integer NOT NULL, "name" character varying, "start_at" timestamp, "end_at" timestamp, "workflow_state" character varying, "grading_period_group_id" integer, "sis_id" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (4.1ms)  CREATE UNIQUE INDEX  "index_terms_on_canvas_id" ON "terms"  ("canvas_id")
+  ActiveRecord::SchemaMigration Create (0.4ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20190702203623"]]
+   (1.2ms)  COMMIT
+Migrating to CreateEnrollments (20190702203624)
+   (0.2ms)  BEGIN
+   (9.2ms)  CREATE TABLE "enrollments" ("id" bigserial primary key, "canvas_id" bigint NOT NULL, "canvas_course_id" bigint, "course_sis_id" character varying, "canvas_user_id" bigint, "user_sis_id" character varying, "role" character varying, "canvas_role_id" integer, "canvas_section_id" bigint, "workflow_state" character varying, "base_role_type" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (3.8ms)  CREATE UNIQUE INDEX  "index_enrollments_on_canvas_id" ON "enrollments"  ("canvas_id")
+   (3.8ms)  CREATE  INDEX  "index_enrollments_on_canvas_course_id" ON "enrollments"  ("canvas_course_id")
+   (4.1ms)  CREATE  INDEX  "index_enrollments_on_canvas_user_id" ON "enrollments"  ("canvas_user_id")
+  ActiveRecord::SchemaMigration Create (0.4ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20190702203624"]]
+   (1.2ms)  COMMIT
+Migrating to CreateSections (20190702203625)
+   (0.2ms)  BEGIN
+   (9.7ms)  CREATE TABLE "sections" ("id" bigserial primary key, "canvas_id" bigint NOT NULL, "sis_id" character varying, "canvas_course_id" bigint, "canvas_nonxlist_course_id" bigint, "name" character varying, "workflow_state" character varying, "start_at" timestamp, "end_at" timestamp, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (4.0ms)  CREATE UNIQUE INDEX  "index_sections_on_canvas_id" ON "sections"  ("canvas_id")
+   (3.6ms)  CREATE  INDEX  "index_sections_on_canvas_course_id" ON "sections"  ("canvas_course_id")
+  ActiveRecord::SchemaMigration Create (0.5ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20190702203625"]]
+   (1.3ms)  COMMIT
+Migrating to CreateAssignments (20190702203626)
+   (0.3ms)  BEGIN
+   (9.0ms)  CREATE TABLE "assignments" ("id" bigserial primary key, "canvas_id" bigint NOT NULL, "title" character varying, "description" text, "due_at" timestamp, "unlock_at" timestamp, "lock_at" timestamp, "points_possible" float, "min_score" float, "max_score" float, "mastery_score" float, "grading_type" character varying, "submission_types" character varying, "workflow_state" character varying, "canvas_context_id" integer, "canvas_context_type" character varying, "canvas_assignment_group_id" integer, "canvas_grading_scheme_id" integer, "canvas_grading_standard_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (3.8ms)  CREATE UNIQUE INDEX  "index_assignments_on_canvas_id" ON "assignments"  ("canvas_id")
+   (3.9ms)  CREATE  INDEX  "index_assignments_on_canvas_context_id_and_canvas_context_type" ON "assignments"  ("canvas_context_id", "canvas_context_type")
+  ActiveRecord::SchemaMigration Create (0.3ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20190702203626"]]
+   (1.3ms)  COMMIT
+Migrating to CreateSubmissions (20190702203627)
+   (0.2ms)  BEGIN
+   (9.0ms)  CREATE TABLE "submissions" ("id" bigserial primary key, "canvas_id" bigint NOT NULL, "canvas_course_id" bigint, "canvas_assignment_id" bigint, "canvas_user_id" bigint, "submitted_at" timestamp, "due_at" timestamp, "graded_at" timestamp, "score" float, "points_possible" float, "excused" boolean, "workflow_state" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (3.9ms)  CREATE UNIQUE INDEX  "index_submissions_on_canvas_id" ON "submissions"  ("canvas_id")
+   (3.7ms)  CREATE  INDEX  "index_submissions_on_canvas_assignment_id" ON "submissions"  ("canvas_assignment_id")
+   (3.9ms)  CREATE  INDEX  "index_submissions_on_canvas_course_id" ON "submissions"  ("canvas_course_id")
+   (3.9ms)  CREATE  INDEX  "index_submissions_on_canvas_user_id" ON "submissions"  ("canvas_user_id")
+  ActiveRecord::SchemaMigration Create (0.3ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20190702203627"]]
+   (1.2ms)  COMMIT
+Migrating to CreateAssignmentGroups (20190702203630)
+   (0.2ms)  BEGIN
+   (9.0ms)  CREATE TABLE "assignment_groups" ("id" bigserial primary key, "canvas_id" bigint NOT NULL, "canvas_course_id" bigint, "name" character varying, "rules" text, "position" integer, "group_weight" float, "workflow_state" character varying, "canvas_created_at" timestamp, "canvas_updated_at" timestamp, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (3.8ms)  CREATE UNIQUE INDEX  "index_assignment_groups_on_canvas_id" ON "assignment_groups"  ("canvas_id")
+   (3.9ms)  CREATE  INDEX  "index_assignment_groups_on_canvas_course_id" ON "assignment_groups"  ("canvas_course_id")
+  ActiveRecord::SchemaMigration Create (0.4ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20190702203630"]]
+   (1.3ms)  COMMIT
+Migrating to CreateContextModules (20190702203631)
+   (0.2ms)  BEGIN
+   (10.4ms)  CREATE TABLE "context_modules" ("id" bigserial primary key, "canvas_id" bigint, "canvas_context_id" bigint, "canvas_context_type" character varying, "position" integer, "name" character varying, "workflow_state" character varying, "deleted_at" timestamp, "unlock_at" timestamp, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (4.1ms)  CREATE UNIQUE INDEX  "index_context_modules_on_canvas_id" ON "context_modules"  ("canvas_id")
+   (3.8ms)  CREATE  INDEX  "index_context_modules_on_context" ON "context_modules"  ("canvas_context_id", "canvas_context_type")
+  ActiveRecord::SchemaMigration Create (0.3ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20190702203631"]]
+   (1.3ms)  COMMIT
+Migrating to CreateContextModuleItems (20190702203632)
+   (0.2ms)  BEGIN
+   (10.0ms)  CREATE TABLE "context_module_items" ("id" bigserial primary key, "canvas_id" bigint, "canvas_context_module_id" bigint, "position" integer, "canvas_content_id" bigint, "canvas_content_type" character varying, "canvas_assignment_id" bigint, "workflow_state" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (3.8ms)  CREATE UNIQUE INDEX  "index_context_module_items_on_canvas_id" ON "context_module_items"  ("canvas_id")
+   (3.9ms)  CREATE  INDEX  "index_context_module_items_on_canvas_context_module_id" ON "context_module_items"  ("canvas_context_module_id")
+  ActiveRecord::SchemaMigration Create (0.5ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20190702203632"]]
+   (1.5ms)  COMMIT
+Migrating to AddForkCountToCanvasSyncJobLogs (20190916154829)
+   (0.3ms)  BEGIN
+   (0.4ms)  ALTER TABLE "canvas_sync_job_logs" ADD "fork_count" integer
+  ActiveRecord::SchemaMigration Create (0.3ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20190916154829"]]
+   (1.0ms)  COMMIT
+Migrating to CreateRoles (20190927204545)
+   (0.1ms)  BEGIN
+   (8.8ms)  CREATE TABLE "roles" ("id" bigserial primary key, "canvas_id" integer NOT NULL, "label" character varying, "base_role_type" character varying, "canvas_account_id" integer, "workflow_state" character varying, "permissions" json, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (3.6ms)  CREATE UNIQUE INDEX  "index_roles_on_canvas_id" ON "roles"  ("canvas_id")
+   (3.8ms)  CREATE  INDEX  "index_roles_on_canvas_account_id" ON "roles"  ("canvas_account_id")
+  ActiveRecord::SchemaMigration Create (0.4ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20190927204545"]]
+   (1.4ms)  COMMIT
+Migrating to CreateAdmins (20190927204546)
+   (0.2ms)  BEGIN
+   (8.5ms)  CREATE TABLE "admins" ("id" bigserial primary key, "canvas_id" bigint NOT NULL, "role_name" character varying, "canvas_account_id" bigint, "canvas_role_id" bigint, "canvas_user_id" bigint, "workflow_state" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (3.9ms)  CREATE UNIQUE INDEX  "index_admins_on_canvas_id" ON "admins"  ("canvas_id")
+   (3.6ms)  CREATE  INDEX  "index_admins_on_canvas_role_id" ON "admins"  ("canvas_role_id")
+   (4.1ms)  CREATE  INDEX  "index_admins_on_canvas_user_id" ON "admins"  ("canvas_user_id")
+   (3.7ms)  CREATE  INDEX  "index_admins_on_canvas_account_id" ON "admins"  ("canvas_account_id")
+  ActiveRecord::SchemaMigration Create (0.6ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20190927204546"]]
+   (1.5ms)  COMMIT
+Migrating to CreateGroups (20200415171620)
+   (0.3ms)  BEGIN
+   (9.3ms)  CREATE TABLE "groups" ("id" bigserial primary key, "canvas_id" bigint NOT NULL, "sis_id" character varying, "canvas_group_category_id" bigint, "group_category_sis_id" character varying, "canvas_account_id" bigint, "canvas_course_id" bigint, "name" character varying, "workflow_state" character varying, "context_id" bigint, "context_type" character varying, "max_membership" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (3.8ms)  CREATE UNIQUE INDEX  "index_groups_on_canvas_id" ON "groups"  ("canvas_id")
+  ActiveRecord::SchemaMigration Create (0.4ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20200415171620"]]
+   (1.4ms)  COMMIT
+Migrating to CreateGroupMemberships (20200416214248)
+   (0.2ms)  BEGIN
+   (14.1ms)  CREATE TABLE "group_memberships" ("id" bigserial primary key, "canvas_id" bigint NOT NULL, "canvas_user_id" bigint NOT NULL, "canvas_group_id" bigint NOT NULL, "group_sis_id" character varying, "user_sis_id" character varying, "workflow_state" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (3.6ms)  CREATE UNIQUE INDEX  "index_group_memberships_on_canvas_id" ON "group_memberships"  ("canvas_id")
+  ActiveRecord::SchemaMigration Create (0.4ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20200416214248"]]
+   (1.7ms)  COMMIT
+Migrating to CreatePseudonyms (20201016181346)
+   (0.3ms)  BEGIN
+   (9.1ms)  CREATE TABLE "pseudonyms" ("id" bigserial primary key, "canvas_id" bigint NOT NULL, "canvas_user_id" bigint, "sis_id" character varying, "unique_id" character varying, "workflow_state" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (3.9ms)  CREATE UNIQUE INDEX  "index_pseudonyms_on_canvas_id" ON "pseudonyms"  ("canvas_id")
+   (3.6ms)  CREATE  INDEX  "index_pseudonyms_on_canvas_user_id" ON "pseudonyms"  ("canvas_user_id")
+  ActiveRecord::SchemaMigration Create (0.4ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20201016181346"]]
+   (1.3ms)  COMMIT
+Migrating to CreateCanvasSyncSyncBatches (20201018210836)
+   (0.2ms)  BEGIN
+   (8.7ms)  CREATE TABLE "canvas_sync_sync_batches" ("id" serial NOT NULL PRIMARY KEY, "started_at" timestamp, "completed_at" timestamp, "status" character varying, "created_at" timestamp, "updated_at" timestamp)
+  ActiveRecord::SchemaMigration Create (0.3ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20201018210836"]]
+   (1.2ms)  COMMIT
+Migrating to AddFullSyncToCanvasSyncSyncBatch (20201030210836)
+   (0.2ms)  BEGIN
+   (0.6ms)  ALTER TABLE "canvas_sync_sync_batches" ADD "full_sync" boolean DEFAULT FALSE
+   (0.5ms)  ALTER TABLE "canvas_sync_sync_batches" ADD "batch_genre" character varying
+   (0.7ms)  ALTER TABLE "canvas_sync_sync_batches" ADD "batch_bid" character varying
+  ActiveRecord::SchemaMigration Create (0.4ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20201030210836"]]
+   (1.5ms)  COMMIT
+Migrating to CreateUserObservers (20210907233329)
+   (0.2ms)  BEGIN
+   (9.8ms)  CREATE TABLE "user_observers" ("id" bigserial primary key, "observing_user_id" bigint, "observed_user_id" bigint, "workflow_state" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (4.1ms)  CREATE UNIQUE INDEX  "index_user_observers_on_observed_user_id_and_observing_user_id" ON "user_observers"  ("observed_user_id", "observing_user_id")
+   (4.0ms)  CREATE  INDEX  "index_user_observers_on_observing_user_id" ON "user_observers"  ("observing_user_id")
+   (3.9ms)  CREATE  INDEX  "index_user_observers_on_observed_user_id" ON "user_observers"  ("observed_user_id")
+  ActiveRecord::SchemaMigration Create (0.4ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20210907233329"]]
+   (1.4ms)  COMMIT
+Migrating to CreateGradingPeriods (20210907233330)
+   (0.3ms)  BEGIN
+   (9.8ms)  CREATE TABLE "grading_periods" ("id" bigserial primary key, "canvas_id" bigint NOT NULL, "title" character varying, "weight" float, "start_date" timestamp, "end_date" timestamp, "close_date" timestamp, "canvas_grading_period_group_id" bigint, "workflow_state" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (4.3ms)  CREATE UNIQUE INDEX  "index_grading_periods_on_canvas_id" ON "grading_periods"  ("canvas_id")
+   (4.0ms)  CREATE  INDEX  "index_grading_periods_on_canvas_grading_period_group_id" ON "grading_periods"  ("canvas_grading_period_group_id")
+  ActiveRecord::SchemaMigration Create (0.4ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20210907233330"]]
+   (1.3ms)  COMMIT
+Migrating to CreateGradingPeriodGroups (20211001184920)
+   (0.3ms)  BEGIN
+   (10.1ms)  CREATE TABLE "grading_period_groups" ("id" bigserial primary key, "canvas_id" bigint NOT NULL, "title" character varying, "weighted" boolean, "display_totals_for_all_grading_periods" boolean, "workflow_state" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (4.0ms)  CREATE UNIQUE INDEX  "index_grading_period_groups_on_canvas_id" ON "grading_period_groups"  ("canvas_id")
+  ActiveRecord::SchemaMigration Create (0.6ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20211001184920"]]
+   (1.2ms)  COMMIT
+Migrating to CreateContentMigrations (20220308072643)
+   (0.2ms)  BEGIN
+   (10.7ms)  CREATE TABLE "content_migrations" ("id" bigserial primary key, "canvas_id" bigint, "canvas_context_id" bigint, "canvas_context_type" character varying, "workflow_state" character varying, "migration_settings" text, "started_at" timestamp, "finished_at" timestamp, "progress" float, "canvas_source_course_id" bigint, "migration_type" character varying, "canvas_child_subscription_id" bigint, "canvas_root_account_id" bigint, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (4.1ms)  CREATE UNIQUE INDEX  "index_content_migrations_on_canvas_id" ON "content_migrations"  ("canvas_id")
+  ActiveRecord::SchemaMigration Create (0.7ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20220308072643"]]
+   (1.5ms)  COMMIT
+Migrating to CreateLearningOutcomes (20220712210559)
+   (0.3ms)  BEGIN
+   (10.5ms)  CREATE TABLE "learning_outcomes" ("id" bigserial primary key, "canvas_id" bigint NOT NULL, "canvas_context_id" integer, "canvas_context_type" character varying, "name" character varying, "friendly_name" character varying, "workflow_state" character varying, "canvas_created_at" timestamp, "canvas_updated_at" timestamp, "migration_id" character varying, "vendor_guid" character varying, "low_grade" character varying, "high_grade" character varying, "calculation_method" character varying, "calculation_int" character varying, "outcome_import_id" integer, "root_account_ids" integer[] DEFAULT '{}', "description" text, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (4.0ms)  CREATE UNIQUE INDEX  "index_learning_outcomes_on_canvas_id" ON "learning_outcomes"  ("canvas_id")
+   (3.9ms)  CREATE  INDEX  "index_learning_outcomes_on_context" ON "learning_outcomes"  ("canvas_context_id", "canvas_context_type")
+  ActiveRecord::SchemaMigration Create (0.5ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20220712210559"]]
+   (1.4ms)  COMMIT
+Migrating to CreateUsers (20220926221926)
+   (0.3ms)  BEGIN
+   (9.6ms)  CREATE TABLE "users" ("id" bigserial primary key, "canvas_id" bigint NOT NULL, "email" character varying, "first_name" character varying, "last_name" character varying, "workflow_state" character varying, "login_id" character varying, "name" character varying, "sortable_name" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL)
+   (4.0ms)  CREATE UNIQUE INDEX  "index_users_on_canvas_id" ON "users"  ("canvas_id")
+  ActiveRecord::SchemaMigration Create (0.4ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1) RETURNING "version"  [["version", "20220926221926"]]
+   (1.4ms)  COMMIT
+  ActiveRecord::InternalMetadata Load (0.5ms)  SELECT  "ar_internal_metadata".* FROM "ar_internal_metadata" WHERE "ar_internal_metadata"."key" = $1 LIMIT $2  [["key", "environment"], ["LIMIT", 1]]
+   (0.4ms)  BEGIN
+  ActiveRecord::InternalMetadata Create (0.6ms)  INSERT INTO "ar_internal_metadata" ("key", "value", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "key"  [["key", "environment"], ["value", "development"], ["created_at", "2022-12-12 21:35:40.947063"], ["updated_at", "2022-12-12 21:35:40.947063"]]
+   (1.3ms)  COMMIT
+   (0.3ms)  SELECT pg_advisory_unlock(1438354376499275445)
+   (0.3ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" ORDER BY "schema_migrations"."version" ASC