sidekiq-amigo 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b5204accb28834a6d5cb0baf274aa92e96f8ab2480316d6578c1e35e31075f44
+  data.tar.gz: c397ff5a38053be56726310f8b5e4e1b934c85c84f17fa60bb636e6d4b477252
+SHA512:
+  metadata.gz: 04ce08ea274cf3132db350ecf826787e594faa47e1905fbc61307156d6b87f6a33b5301c05acf2b88b21aff52d600e52ae7cc31dd83f53e72ac972c5c2b56e0e
+  data.tar.gz: e46d7aab0d27953b1d16903cb98d77e8b8ddcbe56ea091950c76bdf60c18e3207cc085dc2c87e3f0e78c2f7e310325d4de8492c3d73f04babdcbf0a53be2a3f9

data/lib/amigo/audit_logger.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "amigo/job"
+
+class Amigo
+  class AuditLogger
+    include Sidekiq::Worker
+
+    def perform(event_json)
+      Amigo.log(self, :info, "async_job_audit",
+                event_id: event_json["id"],
+                event_name: event_json["name"],
+                event_payload: event_json["payload"],)
+    end
+  end
+end

data/lib/amigo/deprecated_jobs.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "amigo/job"
+
+# Put jobs here to die. If you just remove a job in Sidekiq, it may be queued up
+# (like if it's scheduled or retrying),
+# and will fail if the class does not exist.
+#
+# So, make the class exist, but noop so it won't be scheduled and won't be retried.
+# Then it can be deleted later.
+#
+class Amigo
+  module DeprecatedJobs
+    def self.install(const_base, *names)
+      cls = self.noop_class
+      names.each { |n| self.__install_one(const_base, n, cls) }
+    end
+
+    def self.__install_one(const_base, cls_name, cls)
+      name_parts = cls_name.split("::").map(&:to_sym)
+      name_parts[0..-2].each do |part|
+        const_base = if const_base.const_defined?(part)
+                       const_base.const_get(part)
+        else
+          const_base.const_set(part, Module.new)
+        end
+      end
+      const_base.const_set(name_parts.last, cls)
+    end
+
+    def self.noop_class
+      cls = Class.new do
+        def _perform(*)
+          Amigo.log(self, :warn, "deprecated_job_invoked", nil)
+        end
+      end
+      cls.extend(Amigo::Job)
+      return cls
+    end
+  end
+end

data/lib/amigo/job.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+class Amigo
+  module Job
+    def self.extended(cls)
+      Amigo.registered_jobs << cls
+
+      cls.include(Sidekiq::Worker)
+      cls.extend(ClassMethods)
+      cls.pattern = ""
+      cls.include(InstanceMethods)
+    end
+
+    module InstanceMethods
+      def initialize(*)
+        super
+        @change_matchers = {}
+      end
+
+      def logger
+        return Sidekiq.logger
+      end
+
+      def perform(*args)
+        if args.empty?
+          event = nil
+        elsif args.size == 1
+          event = Amigo::Event.from_json(args[0])
+        else
+          raise "perform should always be called with no args or [Amigo::Event#as_json], got %p" % [args]
+        end
+        self._perform(event)
+      end
+
+      # Return +klass[payload_or_id]+ if it exists, or raise an error if it does not.
+      # +payload_or_id+ can be an integer,
+      # or the async job payload if the id is the first argument.
+      #
+      # Examples:
+      # - `customer = self.lookup_model( MyApp::Customer, event )`
+      # - `customer = self.lookup_model( MyApp::Customer, event.payload )`
+      # - `customer = self.lookup_model( MyApp::Customer, customer_id )`
+      def lookup_model(klass, payload_or_id)
+        if payload_or_id.is_a?(Integer)
+          id = payload_or_id
+        elsif payload_or_id.respond_to?(:payload)
+          id = payload_or_id.payload.first
+        elsif payload_or_id.respond_to?(:first)
+          id = payload_or_id.first
+        else
+          raise "Don't know how to handle #{payload_or_id}"
+        end
+        result = klass[id] or raise "%s[%p] does not exist" % [klass.name, id]
+        return result
+      end
+
+      # Create a matcher against the 'changed' hash of an update event.
+      #
+      # Example:
+      #    on 'myapp.customer.update' do |payload, _|
+      #        customerid, changes, _ = *payload
+      #        customer = MyApp::Customer[ customerid ] or return false
+      #
+      #        case changes
+      #        when changed( :password )
+      #            send_password_change_email( customer )
+      #        when changed( :activation_code, to: nil )
+      #            send_welcome_email( customer )
+      #        when changed( :type, from: 'seeder', to: 'eater' )
+      #            send_becoming_an_eater_email( customer )
+      #        end
+      #    end
+      def changed(field, values={})
+        unless @change_matchers[[field, values]]
+          match_proc = self.make_match_proc_for(field, values)
+          @change_matchers[[field, values]] = match_proc
+        end
+
+        return @change_matchers[[field, values]]
+      end
+
+      # Make a curried Proc for calling a match method with the given +field+ and +values+.
+      def make_match_proc_for(field, values)
+        return self.method(:match_any_change).to_proc.curry[field] if values.empty?
+
+        if values.key?(:from)
+          if values.key?(:to)
+            return self.method(:match_change_from_to).to_proc.
+                curry[ field, values[:from], values[:to] ]
+          else
+            return self.method(:match_change_from).to_proc.
+                curry[ field, values[:from] ]
+          end
+        elsif values.key?(:to)
+          return self.method(:match_change_to).to_proc.
+              curry[ field, values[:to] ]
+        else
+          raise ScriptError,
+                "Unhandled change option/s: %p; expected :to and/or :from" % [values.keys]
+        end
+      end
+
+      # Returns +true+ if the given +field+ is listed at all in the specified
+      # +changes+.
+      def match_any_change(field, changes)
+        self.logger.debug "Checking for existance of field %p in %p" % [field, changes]
+        return changes&.key?(field.to_s)
+      end
+
+      # Returns +true+ if the given +field+ is listed in the specified +changes+,
+      # and the value it changed to matches +to+. The +to+ value can be:
+      #
+      # a Regexp::
+      #   The new value is stringified, and matched against the +to+ Regexp.
+      # an immediate value (String, Numeric, NilClass, etc.)::
+      #   The new value is matched using Object#==.
+      #
+      def match_change_to(field, to, changes)
+        self.logger.debug "Checking for change to %p of field %p in %p" % [to, field, changes]
+        return false unless changes&.key?(field.to_s)
+
+        newval = changes[field.to_s][1]
+
+        case to
+          when NilClass, Numeric, String, TrueClass, FalseClass
+            return newval == to
+          when Regexp
+            return to.match(newval)
+          when Proc
+            return to[newval]
+          else
+            raise TypeError, "Unhandled type of 'to' criteria %p (a %p)" % [to, to.class]
+        end
+      end
+
+      # Returns +true+ if the given +field+ is listed in the specified +changes+,
+      # and the value it changed from matches +from+. The +from+ value can be:
+      #
+      # a Regexp::
+      #   The old value is stringified, and matched against the +from+ Regexp.
+      # an immediate value (String, Numeric, NilClass, etc.)::
+      #   The old value is matched using Object#==.
+      #
+      def match_change_from(field, from, changes)
+        self.logger.debug "Checking for change from %p of field %p in %p" % [from, field, changes]
+        return false unless changes&.key?(field.to_s)
+
+        oldval = changes[field.to_s][0]
+
+        case from
+          when NilClass, Numeric, String, TrueClass, FalseClass
+            return oldval == from
+          when Regexp
+            return from.match(oldval)
+          when Proc
+            return from[oldval]
+          else
+            raise TypeError, "Unhandled type of 'from' criteria %p (a %p)" % [from, from.class]
+        end
+      end
+
+      # Returns +true+ if the given +field+ is listed in the specified +changes+,
+      # and the value it changed from matches +from+ and the value it changed to
+      # matches +to+. The +from+ and +to+ values can be:
+      #
+      # a Regexp::
+      #   The corresponding value is stringified, and matched against the Regexp.
+      # an immediate value (String, Numeric, NilClass, etc.)::
+      #   The corresponding value is matched using Object#==.
+      #
+      def match_change_from_to(field, from, to, changes)
+        self.logger.debug "Checking for change from %p to %p of field %p in %p" %
+          [from, to, field, changes]
+        return false unless changes&.key?(field.to_s)
+        return self.match_change_to(field, to, changes) &&
+            self.match_change_from(field, from, changes)
+      end
+
+      # Create a matcher against a changed Hash JSON column of an update event.
+      #
+      # Example:
+      #    on 'myapp.customer.update' do |payload, _|
+      #        customerid, changes, _ = *payload
+      #
+      #        case changes
+      #        when changed_at( :flags, :trustworthy, to: true )
+      #            mark_customer_safe_in_external_service( customerid )
+      #        end
+      #    end
+      def changed_at(field, index, values={})
+        return self.method(:match_change_at).to_proc.curry[field, index, values]
+      end
+
+      # Return +true+ if `field[index]` has changed in the specified +changes+,
+      # configured by +values+ (contains +from+, +to+, or whatever supported kwargs).
+      # Unlike other matches, +changes+ is expected to be an entire +Hash+
+      # and may contain a value at +index+ in either or both sets of changes.
+      # This method does not attempt to do the matching itself.
+      # Rather, it sets up the data to defer to the other matcher methods.
+      def match_change_at(field, index, values, changes)
+        field = field.to_s
+        return false unless changes&.key?(field)
+        index = index.to_s
+        old_values, new_values = changes[field]
+        unrolled_changes = self.unroll_hash_changes(old_values, new_values)
+        return self.changed(index, values)[unrolled_changes]
+      end
+
+      # Given two hashes that represent the before and after column hash values,
+      # return a hash in the usual "changes" format,
+      # where keys are the hash keys with changed values,
+      # and values are a tuple of the before and after values.
+      def unroll_hash_changes(old_hash, new_hash)
+        old_hash ||= {}
+        new_hash ||= {}
+        return old_hash.keys.concat(new_hash.keys).uniq.each_with_object({}) do |key, h|
+          old_val = old_hash[key]
+          new_val = new_hash[key]
+          h[key] = [old_val, new_val] if old_val != new_val
+        end
+      end
+    end
+
+    module ClassMethods
+      attr_accessor :pattern
+
+      def on(pattern)
+        self.pattern = pattern
+      end
+
+      def scheduled_job?
+        return false
+      end
+
+      def event_job?
+        return true
+      end
+    end
+  end
+end

data/lib/amigo/router.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "amigo/job"
+
+class Amigo
+  class Router
+    include Sidekiq::Worker
+
+    def perform(event_json)
+      event_name = event_json["name"]
+      matches = Amigo.registered_event_jobs.
+        select { |job| File.fnmatch(job.pattern, event_name, File::FNM_EXTGLOB) }
+      matches.each do |job|
+        Amigo.synchronous_mode ? job.new.perform(event_json) : job.perform_async(event_json)
+      end
+    end
+  end
+end

data/lib/amigo/scheduled_job.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+require "sidekiq-cron"
+
+require "amigo"
+
+class Amigo
+  module ScheduledJob
+    def self.extended(cls)
+      Amigo.registered_jobs << cls
+
+      cls.include(Sidekiq::Worker)
+      cls.sidekiq_options(retry: false)
+      cls.extend(ClassMethods)
+      cls.splay_duration = 30
+      cls.include(InstanceMethods)
+    end
+
+    module InstanceMethods
+      def logger
+        return Sidekiq.logger
+      end
+
+      def perform(*args)
+        if args.empty?
+          jitter = rand(0..self.class.splay_duration.to_i)
+          self.class.perform_in(jitter, true)
+        elsif args == [true]
+          self._perform
+        else
+          raise "ScheduledJob#perform must be called with no arguments, or [true]"
+        end
+      end
+    end
+
+    module ClassMethods
+      attr_accessor :cron_expr, :splay_duration
+
+      def scheduled_job?
+        return true
+      end
+
+      def event_job?
+        return false
+      end
+
+      # Return the UTC hour for the given hour and timezone.
+      # For example, during DST, `utc_hour(6, 'US/Pacific')` returns 13 (or, 6 + 7),
+      # while in standard time (not DST) it returns 8 (or, 6 + 8).
+      # This is useful in crontab notation, when we want something to happen at
+      # a certain local time and don't want it to shift with DST.
+      def utc_hour(hour, tzstr)
+        local = TZInfo::Timezone.get(tzstr)
+        utc = TZInfo::Timezone.get("UTC")
+        n = Time.now
+        intz = Time.new(n.year, n.month, n.day, hour, n.min, n.sec, local)
+        inutc = utc.to_local(intz)
+        return inutc.hour
+      end
+
+      def cron(expr)
+        self.cron_expr = expr
+      end
+
+      def splay(duration)
+        self.splay_duration = duration
+      end
+    end
+  end
+end

data/lib/amigo/spec_helpers.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "sidekiq/testing"
+
+class Amigo
+  module SpecHelpers
+    def self.included(context)
+      Sidekiq::Testing.inline!
+      context.before(:each) do |example|
+        Amigo.synchronous_mode = true if example.metadata[:async]
+      end
+      context.after(:each) do |example|
+        Amigo.synchronous_mode = false if example.metadata[:async]
+      end
+      super
+    end
+
+    module_function def snapshot_async_state(opts={})
+      old_hooks = Amigo.subscribers.to_a
+      old_jobs = Amigo.registered_jobs.to_a
+      old_failure = Amigo.on_publish_error
+
+      begin
+        Amigo.on_publish_error = opts[:on_error] if opts.key?(:on_error)
+        Amigo.subscribers.replace(opts[:subscribers]) if opts.key?(:subscribers)
+        Amigo.registered_jobs.replace(opts[:jobs]) if opts.key?(:jobs)
+        yield
+      ensure
+        Amigo.on_publish_error = old_failure
+        Amigo.subscribers.replace(old_hooks)
+        Amigo.registered_jobs.replace(old_jobs)
+      end
+    end
+
+    class EventPublishedMatcher
+      attr_reader :recorded_events
+
+      def initialize(eventname, expected_payload=[])
+        @expected_events = [[eventname, expected_payload]]
+        @recorded_events = []
+        @missing         = []
+        @matched         = []
+      end
+
+      def and(another_eventname, *expected_payload)
+        @expected_events << [another_eventname, expected_payload]
+        return self
+      end
+
+      def with_payload(expected_payload)
+        raise ArgumentError, "expected payload must be an array or matcher" unless
+          expected_payload.is_a?(Array) || expected_payload.respond_to?(:matches?)
+        @expected_events.last[1] = expected_payload
+        return self
+      end
+
+      def record_event(event)
+        Amigo.log nil, :debug, "recording_event", event: event
+        @recorded_events << event
+      end
+
+      def supports_block_expectations?
+        true
+      end
+
+      def matches?(given_proc)
+        unless given_proc.respond_to?(:call)
+          warn "publish matcher used with non-proc object #{given_proc.inspect}"
+          return false
+        end
+
+        unless Amigo.synchronous_mode
+          warn "publish matcher used without synchronous_mode (use :async test metadata)"
+          return false
+        end
+
+        state = {on_error: self.method(:on_publish_error), subscribers: [self.method(:record_event)]}
+        Amigo::SpecHelpers.snapshot_async_state(state) do
+          given_proc.call
+        end
+
+        self.match_expected_events
+
+        return @error.nil? && @missing.empty?
+      end
+
+      def on_publish_error(err)
+        @error = err
+      end
+
+      def match_expected_events
+        @expected_events.each do |expected_event, expected_payload|
+          match = @recorded_events.find do |recorded|
+            recorded.name == expected_event && self.payloads_match?(expected_payload, recorded.payload)
+          end
+
+          if match
+            self.add_matched(expected_event, expected_payload)
+          else
+            self.add_missing(expected_event, expected_payload)
+          end
+        end
+      end
+
+      def payloads_match?(expected, recorded)
+        return expected.matches?(recorded) if expected.respond_to?(:matches?)
+        return expected.nil? || expected.empty? || expected == recorded
+      end
+
+      def add_matched(event, payload)
+        @matched << [event, payload]
+      end
+
+      def add_missing(event, payload)
+        @missing << [event, payload]
+      end
+
+      def failure_message
+        return "Error while publishing: %p" % [@error] if @error
+
+        messages = []
+
+        @missing.each do |event, payload|
+          message = "expected a '%s' event to be fired" % [event]
+          message << " with a payload of %p" % [payload] unless payload.nil?
+          message << " but none was."
+
+          messages << message
+        end
+
+        if @recorded_events.empty?
+          messages << "No events were sent."
+        else
+          parts = @recorded_events.map(&:inspect)
+          messages << "The following events were recorded: %s" % [parts.join(", ")]
+        end
+
+        return messages.join("\n")
+      end
+
+      def failure_message_when_negated
+        messages = []
+        @matched.each do |event, _payload|
+          message = "expected a '%s' event not to be fired" % [event]
+          message << " with a payload of %p" % [@expected_payload] if @expected_payload
+          message << " but one was."
+          messages << message
+        end
+
+        return messages.join("\n")
+      end
+    end
+
+    # RSpec matcher -- set up an expectation that an event will be fired
+    # with the specified +eventname+ and optional +expected_payload+.
+    #
+    #    expect {
+    #        Myapp::Customer.create( attributes )
+    #    }.to publish( 'myapp.customer.create' )
+    #
+    #    expect {
+    #        Myapp::Customer.create( attributes )
+    #    }.to publish( 'myapp.customer.create', [1] )
+    #
+    #    expect { enter_hatch() }.
+    #        to publish( 'myapp.hatch.entered' ).
+    #        with_payload( [4, 8, 15, 16, 23, 42] )
+    #
+    #    expect { cook_potatoes() }.
+    #        to publish( 'myapp.potatoes.cook' ).
+    #        with_payload( including( a_hash_containing( taste: 'good' ) ) )
+    #
+    def publish(eventname=nil, expected_payload=nil)
+      return EventPublishedMatcher.new(eventname, expected_payload)
+    end
+
+    class PerformAsyncJobMatcher
+      include RSpec::Matchers::Composable
+
+      def initialize(job)
+        @job = job
+      end
+
+      # RSpec matcher API -- specify that this matcher supports expect with a block.
+      def supports_block_expectations?
+        true
+      end
+
+      # Return +true+ if the +given_proc+ is a valid callable.
+      def valid_proc?(given_proc)
+        return true if given_proc.respond_to?(:call)
+
+        warn "`perform_async_job` was called with non-proc object #{given_proc.inspect}"
+        return false
+      end
+
+      # RSpec matcher API -- return +true+ if the specified job ran successfully.
+      def matches?(given_proc)
+        return false unless self.valid_proc?(given_proc)
+        return self.run_isolated_job(given_proc)
+      end
+
+      # Run +given_proc+ in a 'clean' async environment, where 'clean' means:
+      # - Async jobs are subscribed to events
+      # - The only registered job is the matcher's job
+      def run_isolated_job(given_proc)
+        unless Amigo.synchronous_mode
+          warn "publish matcher used without synchronous_mode (use :async test metadata)"
+          return false
+        end
+
+        state = {on_error: self.method(:on_publish_error), subscribers: [], jobs: [@job]}
+        Amigo::SpecHelpers.snapshot_async_state(state) do
+          Amigo.install_amigo_jobs
+          given_proc.call
+        end
+
+        return @error.nil?
+      end
+
+      def on_publish_error(err)
+        @error = err
+      end
+
+      def failure_message
+        return "Job errored: %p" % [@error]
+      end
+    end
+
+    def perform_async_job(job)
+      return PerformAsyncJobMatcher.new(job)
+    end
+  end
+end

data/lib/amigo/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Amigo
+  VERSION = "1.0.0"
+end

data/lib/amigo.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require "redis"
+require "sidekiq"
+require "sidekiq-cron"
+
+# Host module and namespace for the Amigo async jobs system.
+#
+# The async job system is mostly decoupled into a few parts,
+# so we can understand them in pieces.
+# Those pieces are: Publish, Subscribe, Event Jobs, Routing, and Scheduled Jobs.
+#
+# Under the hood, the async job system uses Sidekiq.
+# Sidekiq is a background job system that persists its data in Redis.
+# Worker processes process the jobs off the queue.
+#
+# Publish
+#
+# The Amigo module has a very basic pub/sub system.
+# You can use `Amigo.publish` to broadcast an event (event name and payload),
+# and register subscribers to listen to the event.
+# The actual event exchanged is a Amigo::Event, which is a simple wrapper object.
+#
+#   Amigo.publish('myapp.auth.failed', email: params[:email])
+#
+# Subscribe
+#
+# Calling Amigo.register_subscriber registers a hook that listens for events published
+# via Amigo.publish. All the subscriber does is send the events to the Router job.
+#
+# The subscriber should be enabled on clients that should emit events (so all web processes,
+# console work that should have side effects like sending emails, and worker processes).
+#
+# Note that enabling the subscriber on worker processes means that it would be possible
+# for a job to end up in an infinite loop
+# (imagine if the audit logger, which records all published events, published an event).
+# This is expected; be careful of infinite loops!
+#
+# Event Jobs
+#
+# Jobs must `include Amigo::Job`.
+# As per best-practices when writing works, keep them as simple as possible,
+# and put the business logic elsewhere.
+#
+# Standard jobs, which we call event-based jobs, generally respond to published events.
+# Use the `on` method to define a glob pattern that is matched against event names:
+#
+#   class Amigo::CustomerMailer
+#     include Amigo::Job
+#     on 'myapp.customer.created'
+#     def _perform(event)
+#       customer_id = event.payload.first
+#       # Send welcome email
+#     end
+#   end
+#
+# The 'on' pattern can be 'myapp.customer.*' to match all customer events for example,
+# or '*' to match all events. The rules of matching follow File.fnmatch.
+#
+# Jobs must implement a `_perform` method, which takes a Amigo::Event.
+# Note that normal Sidekiq workers use a 'perform' method that takes a variable number of arguments;
+# the base Async::Job class has this method and delegates its business logic to the subclass _perform method.
+#
+# Routing
+#
+# There are two special workers that are important for the overall functioning of the system
+# (and do not inherit from Job but rather than Sidekiq::Worker so they are not classified and treated as 'Jobs').
+#
+# The first is the AuditLogger, which is a basic job that logs all async events.
+# This acts as a useful change log for the state of the database.
+#
+# The second special worker is the Router, which calls `perform` on the event Jobs
+# that match the routing information, as explained in Jobs.
+# It does this by filtering through all event-based jobs and performing the ones with a route match.
+#
+# Scheduled Jobs
+#
+# Scheduled jobs use the sidekiq-cron package: https://github.com/ondrejbartas/sidekiq-cron
+# There is a separate base class, Amigo::ScheduledJob, that takes care of some standard job setup.
+#
+# To implement a scheduled job, `include Amigo::ScheduledJob`,
+# call the `cron` method, and provide a `_perform` method.
+# You can also use an optional `splay` method:
+#
+#   class Amigo::CacheBuster
+#     include Amigo::ScheduledJob
+#     cron '*/10 * * * *'
+#     splay 60.seconds
+#     def _perform
+#       # Bust the cache
+#     end
+#   end
+#
+# This code will run once every 10 minutes or so (check out https://crontab.guru/ for testing cron expressions).
+# The "or so" refers to the _splay_, which is a 'fuzz factor' of how close to the target interval
+# the job may run. So in reality, this job will run every 9 to 11 minutes, due to the 60 second splay.
+# Splay exists to avoid a "thundering herd" issue.
+# Splay defaults to 30s; you may wish to always provide splay, whatever you think for your job.
+#
+class Amigo
+  require "amigo/job"
+  require "amigo/scheduled_job"
+  require "amigo/audit_logger"
+  require "amigo/router"
+
+  class << self
+    attr_accessor :structured_logging
+
+    # Proc called with [job, level, message, params].
+    # By default, logs to the job's logger (or Sidekiq's if job is nil).
+    # If structured_logging is true, the message will be an 'event' without any dynamic info,
+    # if false, the params will be rendered into the message so are suitable for unstructured logging.
+    attr_accessor :log_callback
+
+    def reset_logging
+      self.log_callback = ->(job, level, msg, _params) { (job || Sidekiq).logger.send(level, msg) }
+      self.structured_logging = false
+    end
+
+    def log(job, level, message, params)
+      if self.structured_logging
+        paramstr = params.map { |k, v| "#{k}=#{v}" }.join(" ")
+        message = "#{message} #{paramstr}"
+      end
+      self.log_callback[job, level, message, params]
+    end
+
+    # If true, perform event work synchronously rather than asynchronously.
+    # Only useful for testing.
+    attr_accessor :synchronous_mode
+
+    # Every subclass of Amigo::Job and Amigo::ScheduledJob goes here.
+    # It is used for routing and testing isolated jobs.
+    attr_accessor :registered_jobs
+
+    # An Array of callbacks to be run when an event is published.
+    attr_accessor :subscribers
+
+    # A single callback to be run when an event publication errors.
+    attr_accessor :on_publish_error
+
+    # Publish an event with the specified +eventname+ and +payload+
+    # to any configured publishers.
+    def publish(eventname, *payload)
+      ev = Event.new(SecureRandom.uuid, eventname, payload)
+
+      self.subscribers.to_a.each do |hook|
+        hook.call(ev)
+      rescue StandardError => e
+        self.log(nil, :error, "amigo_subscriber_hook_error", error: e, hook: hook, event: ev)
+        self.on_publish_error.call(e)
+      end
+    end
+
+    # Register a hook to be called when an event is sent.
+    def register_subscriber(&block)
+      raise LocalJumpError, "no block given" unless block
+      self.log nil, :info, "amigo_installed_subscriber", block: block
+      self.subscribers << block
+      return block
+    end
+
+    def unregister_subscriber(block_ref)
+      self.subscribers.delete(block_ref)
+    end
+
+    # Return an array of all Job subclasses that respond to event publishing (have patterns).
+    def registered_event_jobs
+      return self.registered_jobs.select(&:event_job?)
+    end
+
+    # Return an array of all Job subclasses that are scheduled (have intervals).
+    def registered_scheduled_jobs
+      return self.registered_jobs.select(&:scheduled_job?)
+    end
+    #
+    # Register a Amigo subscriber that will publish events to Sidekiq/Redis,
+    # for future routing.
+
+    # Install Amigo so that every publish will be sent to the AuditLogger job
+    # and will invoke the relevant jobs in registered_jobs via the Router job.
+    def install_amigo_jobs
+      return self.register_subscriber do |ev|
+        self._subscriber(ev)
+      end
+    end
+
+    def _subscriber(event)
+      event_json = event.as_json
+      Amigo::AuditLogger.perform_async(event_json)
+      Amigo::Router.perform_async(event_json)
+    end
+    #
+    # # Start the scheduler.
+    # # This should generally be run in the Sidekiq worker process,
+    # # not a webserver process.
+    # def self.start_scheduler
+    #   hash = self.scheduled_jobs.each_with_object({}) do |job, memo|
+    #     self.logger.info "Scheduling %s every %p" % [job.name, job.cron_expr]
+    #     memo[job.name] = {
+    #       "class" => job.name,
+    #       "cron" => job.cron_expr,
+    #     }
+    #   end
+    #   load_errs = Sidekiq::Cron::Job.load_from_hash hash
+    #   raise "Errors loading sidekiq-cron jobs: %p" % [load_errs] if load_errs.present?
+    # end
+  end
+
+  class Event
+    def self.from_json(o)
+      return self.new(o["id"], o["name"], o["payload"])
+    end
+
+    attr_reader :id, :name, :payload
+
+    def initialize(id, name, payload)
+      @id = id
+      @name = name
+      @payload = payload.map { |p| self.safe_stringify(p) }
+    end
+
+    def inspect
+      return "#<%p:%#0x [%s] %s %p>" % [
+        self.class,
+        self.object_id * 2,
+        self.id,
+        self.name,
+        self.payload,
+      ]
+    end
+
+    def as_json(_opts={})
+      return {
+        "id" => self.id,
+        "name" => self.name,
+        "payload" => self.payload,
+      }
+    end
+
+    def to_json(opts={})
+      return JSON.dump(self.as_json(opts))
+    end
+
+    protected def safe_stringify(o)
+      return self.deep_stringify_keys(o) if o.is_a?(Hash)
+      return o
+    end
+
+    def deep_stringify_keys(hash)
+      stringified_hash = {}
+      hash.each do |k, v|
+        stringified_hash[k.to_s] =
+          case v
+            when Hash
+              self.deep_stringify_keys(v)
+            when Array
+              v.map { |i| i.is_a?(Hash) ? self.deep_stringify_keys(i) : i }
+          else
+              v
+          end
+      end
+      stringified_hash
+    end
+  end
+end
+
+Amigo.reset_logging
+Amigo.synchronous_mode = false
+Amigo.registered_jobs = []
+Amigo.subscribers = Set.new
+Amigo.on_publish_error = proc {}

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq-amigo
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Lithic Technology
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-03-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: sidekiq-cron
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'sidekiq-amigo provides a pubsub system and other enhancements around
+  Sidekiq.
+
+'
+email: hello@lithic.tech
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/amigo.rb
+- lib/amigo/audit_logger.rb
+- lib/amigo/deprecated_jobs.rb
+- lib/amigo/job.rb
+- lib/amigo/router.rb
+- lib/amigo/scheduled_job.rb
+- lib/amigo/spec_helpers.rb
+- lib/amigo/version.rb
+homepage: https://github.com/lithictech/sidekiq-amigo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Pubsub system and other enhancements around Sidekiq.
+test_files: []