canvas_sync 0.20.5 → 0.21.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f59e793e475e0b39b8ec22a5d0f27144e6734a83020874c9d45b0d78c48c1c60
-  data.tar.gz: fd32c923becad3bb3845979edb6344be3974fbe598908ec2ec99697fbe449703
+  metadata.gz: f498c3b1d47cc2a0d9b7e766cba55bf3b5aa7e361551ac9fbd30890c59e6f681
+  data.tar.gz: 79b1b5e0efd2a7aa0e4026e9b4cbb5bfa666598f854e0d6f8e94d80be160288f
 SHA512:
-  metadata.gz: b117ba9091d2da2e6aea6b1277ebd7cf61bdb127f9dc4e8c2ea2d87ade654cc791950af800053095f8cce13dcf99b231f541472e845fe10fdca2021e85b8028f
-  data.tar.gz: 8d033ae9f1b2fb233d4706d0953bc4ac0d04dd2a7da6d26414d62f700be2c39e3d6a9755703816c763f5dd5b22f6685d0f259f3bfa82453c84b58beff4ec2fb1
+  metadata.gz: c2f4e22caa099836185de175d1ced94113f0e4e9f1a56b7c1b60dad10444ea771563b3c2a95bed4a05acd66ca53db070228d3383bd6aa9a5ecd4e97faf4a3791
+  data.tar.gz: e33eb81f9acec4602bcbd97434d7ad9744b41fd7d0846e786c3eb496a28b3b41be8d94134d445fe63942bfc1262dcd0abfb7225056284ece4733fc15e52220b8

data/README.md

@@ -9,7 +9,7 @@ Add this line to your application's Gemfile:
 ```ruby
 gem 'canvas_sync'
 ```
-
+mount CanvasSync::Engine, at: '/canvas_sync'
 Models and migrations can be installed using the following generator:
 
 ```
@@ -50,18 +50,14 @@ Make sure you've setup sidekiq to work properly with ActiveJob as [outlined here
 
 If using apartment and sidekiq make sure you include the [apartment-sidekiq](https://github.com/influitive/apartment-sidekiq) gem so that the jobs are run in the correct tenant.
 
-## Basic Usage
-
-Your tool must have an `ActiveJob` compatible job queue adapter configured, such as DelayedJob or Sidekiq. Additionally, you must have a method called `canvas_sync_client` defined in an initializer that returns a Bearcat client for the Canvas instance you are syncing against. Example:
+### Live Events
+if enabling Live Events, the following additional dependencies are required:
+- If using Core/Data Services events: `httparty`, `json-jwt`
+- If using EventsManager/DejaVu events: `symmetric-encryption`
 
-```ruby
-# config/initializers/canvas_sync.rb
-def canvas_sync_client
-  Bearcat::Client.new(token: current_organization.settings[:api_token], prefix: current_organization.settings[:base_url])
-end
-```
+## Basic Usage
 
-(Having the client defined here means the sensitive API token doesn't have to be passed in plain text between jobs.)
+Your tool must have an `ActiveJob` compatible job queue adapter configured, such as DelayedJob or Sidekiq.
 
 Once that's done and you've used the generator to create your models and migrations you can run the standard provisioning sync:
 
@@ -83,6 +79,47 @@ If you pass in the optional `term_scope` the provisioning reports will be run fo
 
 Imports are inserted in bulk with [activerecord-import](https://github.com/zdennis/activerecord-import) so they should be very fast.
 
+### Live Events
+
+Ensure that
+```ruby
+mount CanvasSync::Engine, at: '/canvas_sync'
+```
+is added to your `routes.rb`. Configure `DataServices` or `EventsManager` to send events to `https://YOUR_APP/canvas_sync/api/v1/live_event` (if using `DataServices`, event must be signed).
+
+Uncomment `include CanvasSync::Concerns::LiveEventSync` and related lines in the appropriate models. (Some models provide some basic hooks to address a "typical" workflow).
+
+When Live Events are received, the corresponding model (if present) instance will receive `process_live_event(subtype, payload, metadata)` (where `subtype` is the event name w/o the model name - eg `user_created` => `created`). The default logic is to call `ApiSyncable` and update the model from the Canvas API. `process_live_event` can be overridden directly, or hooked with the usual Rails callbacks system (eg `before_process_live_event`).
+
+You can subscribe to Live Events outside of a model context using an intializer like so:
+```ruby
+CanvasSync::LiveEvents.subscribe(%w[Optional List of Events]) do |event|
+  # Your code here
+  # Note that this code is _not_ retried if it fails. If you need retries, use this block to trigger another Job.
+end
+```
+
+#### Event Provenance
+
+When using `EventsManager` events, events are verified as having come from a legitimate source by use of `SymmetricEncryption` (and thus `PRODUCTION_KEY1` will need to be set correctly when deployed).
+
+When using `DataServices`, CanvasSync uses the `DataServices` JWK to authenticate incoming events. CanvasSync is coded to default to the Prod & Beta JWK URL at https://8axpcl50e4.execute-api.us-east-1.amazonaws.com/main/jwks, but this can be overridden with the `DATASERVICES_JWK_URL` ENV variable.
+
+Additionally, when `PandaPal` is installed too, use `https://YOUR_APP/canvas_sync/api/v1/live_event?org=ORG_ID` instead. `CanvasSync` will automatically switch to the correct organization and will validate that the event was indeed from the correct Canvas instance. If you are not using `PandaPal`, you'll need to monkey-patch `CanvasSync::Api::V1::LiveEventsController#validate_tenant!`
+
+#### Legacy-Style Event Jobs
+
+CanvasSync also supports they legacy style of Event Handlers. In this design, properly-named classes are defined in the `::LiveEvents` module, such as (`class LiveEvents::UserCreatedEvent`). Any `ActiveJob` job is compatible, but CanvasSync also provides `CanvasSync::LiveEvents::BaseHandler` as a helpful base class.
+
+When present, these jobs will, per event type (eg `user_created`), override the default behavior, meaning that `subscribe` blocks and `process_live_event` and related callbacks will _not_ be called unless you call them. In other words: If you define `class LiveEvents::UserCreatedEvent` and also
+```ruby
+subscribe(%w[user_created user_updated]) do |event|
+  # ...
+end
+```
+the subscribe block (and User model) will receive `user_updated` events, but not `user_created` events.
+
+These jobs can also be generated from template using `bin/rails generate canvas_sync:install_live_events --events users,courses,etc`
 
 ## Advanced Usage
 
@@ -326,9 +363,22 @@ pool.add_jobs([
 
 # ...Later
 CanvasSync::JobBatches::Pool.from_pid(pool_id).cleanup_redis
+```
 
+### Custom Bearcat Instance
+You can define a global `canvas_sync_client` method to return a Bearcat Client instance for CanvasSync to use:
+```ruby
+# config/initializers/canvas_sync.rb
+def canvas_sync_client
+  Bearcat::Client.new(token: current_organization.settings[:api_token], prefix: current_organization.settings[:base_url])
+end
 ```
 
+(Having the client defined here means the sensitive API token doesn't have to be passed in plain text between jobs.)
+
+This used to be required, but when both CanvasSync and PandaPal are up to date, this is defined automagically.
+
+
 ## Legacy Support
 
 ### Legacy Mappings
@@ -468,7 +518,9 @@ Re-running the generator when there's been a gem change will give you several ch
 
 Additionally, if there have been schema changes to an existing model you may have to run your own migration to bring it up to speed.
 
-If you make updates to the gem please add any upgrade instructions here.
+Also see `CHANGELOG.md`.
+
+If you make updates to the gem please add any upgrade instructions to `CHANGELOG.md`.
 
 ## Integrating with existing applications
 

data/app/controllers/canvas_sync/api/v1/live_events_controller.rb

@@ -0,0 +1,122 @@
+module CanvasSync::Api
+  module V1
+    class LiveEventsController < ActionController::Base
+      around_action :switch_tenant
+
+      def process_event
+        if params[:payload].present?
+          process_eventsmanager_event
+        else
+          process_dataservices_event
+        end
+      rescue => e
+        Rails.logger.error("Live Events Error: #{e.message} - #{e.backtrace}")
+        render json: { error: "Live Events Error: #{e.message}" }, status: 422
+      end
+
+      private
+
+      def process_eventsmanager_event
+        event = SymmetricEncryption.decrypt(params[:payload])
+        event = JSON.parse(event).with_indifferent_access
+
+        event[:metadata] = event[:attributes]
+        event.delete(:attributes)
+
+        Rails.logger.debug("Processing event type: #{event['metadata']['event_name']}")
+        Rails.logger.debug("Payload: #{event}")
+
+        validate_tenant!(event.dig(:metadata, :root_account_uuid))
+        transform_ids!(event)
+        event[:via] = "eventsmanager"
+
+        dispatch_event(event)
+
+        head :ok
+      end
+
+      def process_dataservices_event
+        require "json/jwt"
+        require "httparty"
+
+        event = nil
+
+        # Only allow unsigned events during devleopment
+        if Rails.env.development?
+          event = JSON.parse(request.raw_post) rescue nil
+        end
+
+        event ||= JSON::JWT.decode(request.raw_post, dataservices_jwks)
+        event = event.with_indifferent_access
+
+        Rails.logger.debug("Processing event type: #{event['metadata']['event_name']}")
+        Rails.logger.debug("Payload: #{event}")
+
+        validate_tenant!(event.dig(:metadata, :root_account_uuid))
+        transform_ids!(event)
+        event[:via] = "dataservices"
+
+        dispatch_event(event)
+
+        head :ok
+      end
+
+      def dispatch_event(event)
+        CanvasSync::LiveEvents::ProcessEventJob.perform_later(event)
+      end
+
+      # Live events will use a canvas global ID (cross shard) for any ID's provided. This method will return the local ID.
+      def local_canvas_id(id)
+        # TODO: Don't apply this to cross-shard entries
+        id.to_i % 10_000_000_000_000
+      end
+
+      def transform_ids!(data)
+        transformed = {}
+        data.each do |k, v|
+          if k.ends_with?("_id") && (v.is_a?(String) || v.is_a?(Numeric))
+            transformed["sharded_#{k}"] = v
+            transformed[k] = local_canvas_id(v) rescue v
+          elsif v.is_a?(Hash)
+            transform_ids!(v)
+          end
+        end
+        data.merge!(transformed)
+      end
+
+      def dataservices_jwks
+        require "httparty"
+
+        jwk_json = Rails.cache.fetch("canvas_sync/dataservices_jwks", expires_in: 24.hours) do
+          jkws_url = ENV["DATASERVICES_JWK_URL"].presence || "https://8axpcl50e4.execute-api.us-east-1.amazonaws.com/main/jwks"
+          response = HTTParty.get(jkws_url)
+          JSON.parse(response.body)
+        end
+
+        JSON::JWK::Set.new(jwk_json)
+      end
+
+      def validate_tenant!(event_uuid)
+        if defined?(PandaPal)
+          root_info = current_organization.root_account_info
+          root_uuid = root_info[:uuid]
+
+          if !root_uuid.present? || root_uuid != event_uuid
+            render json: { error: "Invalid Organization/UUID" }, status: 403
+            return
+          end
+        else
+          raise "No way to validate LiveEvent is genuinely from the correct Canvas instance! Monkey-patch CanvasSync::Api::V1::LiveEventsController#validate_tenant!"
+        end
+      end
+
+      def switch_tenant(&block)
+        if defined?(PandaPal) && (org = params[:organization] || params[:org]).present?
+          Apartment::Tenant.switch(PandaPal::Organization.find(org).name, &block)
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,7 @@
+CanvasSync::Engine.routes.draw do
+  namespace "api" do
+    namespace "v1" do
+      post '/live_event' => 'live_events#process_event'
+    end
+  end
+end

data/lib/canvas_sync/concerns/live_event_sync.rb

@@ -0,0 +1,46 @@
+
+module CanvasSync::Concerns
+  module LiveEventSync
+    extend ActiveSupport::Concern
+
+    included do
+      define_model_callbacks :process_live_event
+    end
+
+    class_methods do
+      def cs_internal_process_live_event(event)
+        meta = event[:metadata]
+        payload = event[:payload]
+
+        canvas_id = payload[:id] || payload[:"#{name.underscore}_id"]
+        inst = self.find_or_initialize_by(canvas_id: canvas_id)
+        model, _, subtype = meta[:event_name].rpartition('_')
+
+        result = inst.run_callbacks(:process_live_event) do
+          inst.process_live_event(subtype.to_sym, payload, meta)
+        end
+
+        inst.save! if result != false && inst.changed?
+      end
+    end
+
+    def process_live_event(event_type, payload, metadata)
+      api_response = request_from_api
+      assign_from_api_params(api_response)
+    end
+  end
+
+  CanvasSync::LiveEvents.listen do |event|
+    meta = event[:metadata]
+    payload = event[:payload]
+
+    event_type = meta[:event_name]
+
+    model, _, subtype = event_type.rpartition('_')
+    mcls = model.classify.constantize rescue nil
+
+    if mcls.present? && mcls < LiveEventSync
+      mcls.cs_internal_process_live_event(event)
+    end
+  end
+end

data/lib/canvas_sync/generators/install_live_events_generator.rb

@@ -36,7 +36,6 @@ module CanvasSync
           template rb_file.to_s, "app/services/live_events/#{File.basename(rb_file)}"
         end
       end
-      template "base_event.rb", "app/services/live_events/base_event.rb"
     end
   end
 end

data/lib/canvas_sync/generators/templates/models/account.rb

@@ -4,6 +4,7 @@ class Account < ApplicationRecord
   include CanvasSync::Record
   include CanvasSync::Concerns::ApiSyncable
   # include CanvasSync::Concerns::Account::Ancestry # Add support for the ancestry Gem
+  # include CanvasSync::Concerns::LiveEventSync
 
   canvas_sync_features :defaults
 

data/lib/canvas_sync/generators/templates/models/assignment.rb

@@ -3,6 +3,7 @@
 class Assignment < ApplicationRecord
   include CanvasSync::Record
   include CanvasSync::Concerns::ApiSyncable
+  # include CanvasSync::Concerns::LiveEventSync
 
   canvas_sync_features :defaults
 

data/lib/canvas_sync/generators/templates/models/assignment_group.rb

@@ -3,6 +3,7 @@
 class AssignmentGroup < ApplicationRecord
   include CanvasSync::Record
   include CanvasSync::Concerns::ApiSyncable
+  # include CanvasSync::Concerns::LiveEventSync
 
   canvas_sync_features :defaults
 

data/lib/canvas_sync/generators/templates/models/context_module.rb

@@ -6,6 +6,7 @@
 class ContextModule < ApplicationRecord
   include CanvasSync::Record
   include CanvasSync::Concerns::ApiSyncable
+  # include CanvasSync::Concerns::LiveEventSync
 
   canvas_sync_features :defaults
 

data/lib/canvas_sync/generators/templates/models/context_module_item.rb

@@ -3,6 +3,7 @@
 class ContextModuleItem < ApplicationRecord
   include CanvasSync::Record
   include CanvasSync::Concerns::ApiSyncable
+  # include CanvasSync::Concerns::LiveEventSync
 
   canvas_sync_features :defaults
 

data/lib/canvas_sync/generators/templates/models/course.rb

@@ -6,6 +6,14 @@ class Course < ApplicationRecord
 
   canvas_sync_features :defaults
 
+  # include CanvasSync::Concerns::LiveEventSync
+  # after_process_live_event do
+  #   if account.nil?
+  #     acc = Account.new(canvas_id: canvas_account_id)
+  #     acc.sync_from_api
+  #   end
+  # end
+
   validates :canvas_id, uniqueness: true, presence: true
   belongs_to :term, foreign_key: :canvas_term_id, primary_key: :canvas_id, optional: true
   has_many :enrollments, primary_key: :canvas_id, foreign_key: :canvas_course_id

data/lib/canvas_sync/generators/templates/models/enrollment.rb

@@ -6,6 +6,14 @@ class Enrollment < ApplicationRecord
 
   canvas_sync_features :defaults
 
+  # include CanvasSync::Concerns::LiveEventSync
+  # after_process_live_event do
+  #   if user.nil?
+  #     u = User.new(canvas_id: canvas_user_id)
+  #     u.sync_from_api
+  #   end
+  # end
+
   validates :canvas_id, uniqueness: true, presence: true
   belongs_to :user, primary_key: :canvas_id, foreign_key: :canvas_user_id, optional: true
   belongs_to :role, primary_key: :canvas_id, foreign_key: :canvas_role_id, optional: true

data/lib/canvas_sync/generators/templates/models/section.rb

@@ -6,6 +6,13 @@ class Section < ApplicationRecord
 
   canvas_sync_features :defaults
 
+  # include CanvasSync::Concerns::LiveEventSync
+  # after_process_live_event do
+  #   # A section change could constitute a crosslisting change, which means
+  #   # we need to make sure all our enrollments are pointing to the correct course
+  #   enrollments.update_all(canvas_course_id: canvas_course_id)
+  # end
+
   validates :canvas_id, uniqueness: true, presence: true
   belongs_to :course, primary_key: :canvas_id, foreign_key: :canvas_course_id, optional: true
   has_many :enrollments, primary_key: :canvas_id, foreign_key: :canvas_section_id

data/lib/canvas_sync/generators/templates/models/submission.rb

@@ -3,6 +3,7 @@
 class Submission < ApplicationRecord
   include CanvasSync::Record
   include CanvasSync::Concerns::ApiSyncable
+  # include CanvasSync::Concerns::LiveEventSync
 
   canvas_sync_features :defaults
 

data/lib/canvas_sync/generators/templates/models/user.rb

@@ -6,6 +6,14 @@ class User < ApplicationRecord
 
   canvas_sync_features :defaults
 
+  # include CanvasSync::Concerns::LiveEventSync
+  # around_process_live_event do |blk|
+  #   blk.call
+  # rescue Footrest::HttpError::Unauthorized => e
+  #   # This can happen when a new user is created, but hasn't setup a login on Canvas yet.
+  #   Rails.logger.info("Failed to fetch user #{canvas_user_id}: #{e.backtrace}")
+  # end
+
   validates :canvas_id, uniqueness: true, presence: true
   has_many :pseudonyms, primary_key: :canvas_id, foreign_key: :canvas_user_id
   has_many :enrollments, primary_key: :canvas_id, foreign_key: :canvas_user_id

data/lib/canvas_sync/generators/templates/services/live_events/assignment_event.rb

@@ -1,7 +1,7 @@
 # <%= autogenerated_event_warning %>
 
 module LiveEvents
-  class AssignmentEvent < LiveEvents::BaseEvent
+  class AssignmentEvent < CanvasSync::LiveEvents::BaseHandler
 
     def process
       canvas_assignment_id = local_canvas_id(payload[:assignment_id])

data/lib/canvas_sync/generators/templates/services/live_events/assignment_group_event.rb

@@ -1,7 +1,7 @@
 # <%= autogenerated_event_warning %>
 
 module LiveEvents
-  class AssignmentGroupEvent < LiveEvents::BaseEvent
+  class AssignmentGroupEvent < CanvasSync::LiveEvents::BaseHandler
 
     def process
       canvas_assignment_group_id = local_canvas_id(payload[:assignment_group_id])

data/lib/canvas_sync/generators/templates/services/live_events/course_event.rb

@@ -1,8 +1,7 @@
 # <%= autogenerated_event_warning %>
 
 module LiveEvents
-  class CourseEvent < LiveEvents::BaseEvent
-
+  class CourseEvent < CanvasSync::LiveEvents::BaseHandler
     def process
       course = Course.where(canvas_id: local_canvas_id(payload[:course_id])).first_or_initialize
       course.canvas_account_id = local_canvas_id(payload[:account_id])
@@ -12,7 +11,6 @@ module LiveEvents
       end
       course.sync_from_api
     end
-
   end
 
   class CourseCreatedEvent < LiveEvents::CourseEvent; end

data/lib/canvas_sync/generators/templates/services/live_events/course_section_event.rb

@@ -1,7 +1,7 @@
 # <%= autogenerated_event_warning %>
 
 module LiveEvents
-  class CourseSectionEvent < LiveEvents::BaseEvent
+  class CourseSectionEvent < CanvasSync::LiveEvents::BaseHandler
 
     def process
       section = Section.where(canvas_id: local_canvas_id(payload[:course_section_id])).first_or_initialize

data/lib/canvas_sync/generators/templates/services/live_events/enrollment_event.rb

@@ -1,7 +1,7 @@
 # <%= autogenerated_event_warning %>
 
 module LiveEvents
-  class EnrollmentEvent < LiveEvents::BaseEvent
+  class EnrollmentEvent < CanvasSync::LiveEvents::BaseHandler
     attr_accessor :enrollment
 
     def process()

data/lib/canvas_sync/generators/templates/services/live_events/grade_event.rb

@@ -1,7 +1,7 @@
 # <%= autogenerated_event_warning %>
 
 module LiveEvents
-  class GradeEvent < LiveEvents::BaseEvent
+  class GradeEvent < CanvasSync::LiveEvents::BaseHandler
 
     def process
       raise "process must be implemented in your subclass"

data/lib/canvas_sync/generators/templates/services/live_events/module_event.rb

@@ -1,7 +1,7 @@
 # <%= autogenerated_event_warning %>
 
 module LiveEvents
-  class ModuleEvent < LiveEvents::BaseEvent
+  class ModuleEvent < CanvasSync::LiveEvents::BaseHandler
 
     def process
       return unless payload["context_type"] == "Course"

data/lib/canvas_sync/generators/templates/services/live_events/module_item_event.rb

@@ -1,7 +1,7 @@
 # <%= autogenerated_event_warning %>
 
 module LiveEvents
-  class ModuleItemEvent < LiveEvents::BaseEvent
+  class ModuleItemEvent < CanvasSync::LiveEvents::BaseHandler
 
     def process
       context_module_item = ContextModuleItem.find_or_initialize_by(canvas_id: payload["module_item_id"])

data/lib/canvas_sync/generators/templates/services/live_events/submission_event.rb

@@ -1,7 +1,7 @@
 # <%= autogenerated_event_warning %>
 
 module LiveEvents
-  class SubmissionEvent < LiveEvents::BaseEvent
+  class SubmissionEvent < CanvasSync::LiveEvents::BaseHandler
 
     def process
       submission = Submission.where(canvas_id: local_canvas_id(payload["submission_id"])).first_or_initialize

data/lib/canvas_sync/generators/templates/services/live_events/syllabus_event.rb

@@ -1,7 +1,7 @@
 # <%= autogenerated_event_warning %>
 
 module LiveEvents
-  class SyllabusEvent < LiveEvents::BaseEvent
+  class SyllabusEvent < CanvasSync::LiveEvents::BaseHandler
 
     def process
       # syllabus = Syllabus.where(course_id: attrs[:course_id]).first_or_initialize

data/lib/canvas_sync/generators/templates/services/live_events/user_event.rb

@@ -1,8 +1,7 @@
 # <%= autogenerated_event_warning %>
 
 module LiveEvents
-  class UserEvent < LiveEvents::BaseEvent
-
+  class UserEvent < CanvasSync::LiveEvents::BaseHandler
     def process
       canvas_user_id = local_canvas_id(payload[:user_id])
       user = User.where(canvas_id: canvas_user_id).first_or_initialize
@@ -11,7 +10,6 @@ module LiveEvents
       # This can happen when a new user is created, but hasn't setup a login on Canvas yet.
       Rails.logger.info("Failed to fetch user #{canvas_user_id}: #{e.backtrace}")
     end
-
   end
 
   class UserCreatedEvent < LiveEvents::UserEvent; end

data/lib/canvas_sync/{generators/templates/services/live_events/base_event.rb → live_events/base_handler.rb}

@@ -1,29 +1,25 @@
-# <%= autogenerated_event_warning %>
-
-module LiveEvents
+module CanvasSync::LiveEvents
   class RetryLiveEventJob < StandardError; end
 
-  class BaseEvent < CanvasSync::Job
+  # Deprecated
+  class BaseHandler < CanvasSync::Job
     attr_accessor :raw_payload
     attr_accessor :payload
     attr_accessor :metadata
 
     def perform(event_payload)
       @raw_payload = event_payload
-      @metadata = HashWithIndifferentAccess.new(event_payload["attributes"])
+      @metadata = HashWithIndifferentAccess.new(event_payload["metadata"])
       @payload = HashWithIndifferentAccess.new(event_payload["body"])
       process_with_retry
     end
 
+    protected
+
     def process
       raise "process must be implemented in your subclass"
     end
 
-    # Live events will use a canvas global ID (cross shard) for any ID's provided. This method will return the local ID.
-    def local_canvas_id(id)
-      id.to_i % 10_000_000_000_000
-    end
-
     private
 
     # Sometimes a creation and update event get sent by Canvas at almost the exact same time. This means

data/lib/canvas_sync/live_events/process_event_job.rb

@@ -0,0 +1,25 @@
+
+module CanvasSync::LiveEvents
+  class ProcessEventJob < ::CanvasSync::Job
+    def perform(event)
+      event = event.with_indifferent_access
+
+      # Support Legacy-Style Event Handlers
+      begin
+        legacy_handler = "LiveEvents::#{event['metadata']['event_name'].camelcase}Event".constantize
+        legacy_handler.perform_later(event)
+        return
+      rescue LoadError
+      end
+
+      handlers = CanvasSync::LiveEvents.registered_handlers
+      handlers.each do |h|
+        h.call(event)
+      rescue => e
+        throw e if Rails.env.test?
+        Rails.logger.error("LiveEvent Handler raised Error: #{e}")
+        Raven.captureException(e) if defined? Raven
+      end
+    end
+  end
+end

data/lib/canvas_sync/live_events.rb

@@ -0,0 +1,38 @@
+require_relative './live_events/base_handler.rb'
+require_relative './live_events/process_event_job.rb'
+
+module CanvasSync
+  module LiveEvents
+
+    @@registered_handlers = []
+
+    class << self
+      def listen(event_types = nil, &blk)
+        if event_types != nil
+          blk = wrap_method(blk) do |inner, event|
+            meta = event[:metadata]
+            payload = event[:payload]
+
+            if event_types.include?(meta[:event_name])
+              inner.call(*args)
+            end
+          end
+        end
+
+        @@registered_handlers << blk
+      end
+
+      def registered_handlers
+        @@registered_handlers
+      end
+
+      private
+
+      def wrap_method(inner, &outer)
+        ->(*args) {
+          outer.call(inner, *args)
+        }
+      end
+    end
+  end
+end