icalia-sdk-event-notification 0.1.13 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 109e08255174b6123e57a7e78f1ef0070a6b1df9a08625aa264d0da59bc7e6b1
-  data.tar.gz: 8d1df1d8b155db6cdcb7add13e17fb4f6bf16fc972b5eb5e0175a62d014339bb
+  metadata.gz: ef20f61096dca725e5d61ebc6cc7629b33b694ea61142e4a4bdf331dacff2a2c
+  data.tar.gz: 4fb4d685249caf1dd80ed0322a2a412c0c3053e3876f769b770d56f9a749b9b0
 SHA512:
-  metadata.gz: 1393bedd16f478a3d658e20770ca9b65d70d40fff1390580b2d491f7d4a07752da2f01599b33c6a76e1d891b078afb7a2393c32a9431273de4ccafc8b6869d42
-  data.tar.gz: 22796d27e9f973008c558c24f823dcd0ccd7db9576ab7dba0c461bdac19a063ead7b2ced47a3d0e403419aff16aa89ddc33d6aae62bdb39758f22cb1de47cecb
+  metadata.gz: 6ba2954b5171714bfb90a1e21e80efc3fb3af118ac8d48d42f775af1028d6e292432a197447af9e847e432c8109cade762c4ec367f94cea36359ff1c55a44d6d
+  data.tar.gz: 7b0b343f021ae429163c58d17545495572a3aa6acba53570981663a6d1a983cd5b07d6d1007595a963d2cac529562591e00f7a54dd2089bfa81f1ca671b809a8

data/lib/icalia-sdk-event-notification.rb

@@ -11,33 +11,9 @@ module Icalia
     autoload :Publisher, 'icalia-sdk-event-notification/publisher'
     autoload :Notification, 'icalia-sdk-event-notification/notification'
     
-    autoload :Shoryuken, 'icalia-sdk-event-notification/shoryuken'
-    
     autoload :TopicMessageProcessing,
              'icalia-sdk-event-notification/topic_message_processing'
 
-    def self.generic_aws_client_options
-      {
-        region: ENV.fetch('AWS_REGION', 'us-west-2'),
-        access_key_id: ENV.fetch('AWS_ACCESS_KEY_ID'),
-        secret_access_key: ENV.fetch('AWS_SECRET_ACCESS_KEY')
-      }
-    end
-
-    def self.sqs_client_options
-      options = Icalia::Event.generic_aws_client_options
-      return options if ENV['AWS_SQS_ENDPOINT'].blank?
-      
-      options.merge endpoint: ENV['AWS_SQS_ENDPOINT'], verify_checksums: false
-    end
-
-    def self.sns_client_options
-      options = Icalia::Event.generic_aws_client_options
-      return options if ENV['AWS_SNS_ENDPOINT'].blank?
-      
-      options.merge endpoint: ENV['AWS_SQS_ENDPOINT']
-    end
-
     mattr_reader :deferred_publishing, default: true
   end
 end

data/lib/icalia-sdk-event-notification/publisher.rb

@@ -1,16 +1,21 @@
 # frozen_string_literal: true
 
-require 'aws-sdk-sns'
+require 'google/cloud/pubsub'
 
 require 'active_support'
 require 'active_support/logger'
 
 module Icalia::Event
-  class Publisher
+  module GRPCRailsLogger
+    def logger; Rails.logger; end
+  end
 
-    class UnknownTopicError < StandardError
-    end
+  module GRPCStdoutLogger
+    LOGGER = ActiveSupport::Logger.new(STDOUT)
+    def logger; LOGGER; end
+  end
 
+  class Publisher
     class << self
       def instance
         @instance ||= new
@@ -19,41 +24,48 @@ module Icalia::Event
       delegate :publish, to: :instance
     end
 
-    attr_reader :sns_client, :logger
+    attr_reader :client, :logger
+
+    delegate :encode, to: ActiveSupport::JSON, prefix: :json
 
     def initialize
-      set_sns_client
-      set_logger
+      initialize_pubsub_client
+      initialize_logger
     end
 
-    def publish(topic_name, data, json_data: true)
-      raise UnknownTopicError, "Topic '#{topic_name}' does not exist" \
-        unless topic_exists?(topic_name)
-
-      topic = get_topic topic_name
+    def publish(topic_name, data, attributes = { json_data: true })
       logger.debug "Publishing to '#{topic_name}': #{data.inspect}"
-      topic.publish message: (json_data ? json_encode(data) : data)
+      encoded_data = attributes[:json_data] ? json_encode(data) : data
+      get_or_create_topic(topic_name).publish(encoded_data, attributes)
     end
 
-    delegate :encode, to: ActiveSupport::JSON, prefix: :json
-
     protected
 
-    def get_topic(topic_name)
-      sns_client.topics.detect do |topic|
-        topic.arn.split(':').last == topic_name
-      end
-    end
-
-    def topic_exists?(topic_name)
-      get_topic(topic_name).present?
+    def get_or_create_topic(topic_name)
+      client.topic(topic_name) || client.new_topic(topic_name)
     end
 
-    def set_sns_client
-      @sns_client = Aws::SNS::Resource.new Icalia::Event.sns_client_options
+    private
+
+    # See https://googleapis.dev/ruby/google-cloud-pubsub/latest/file.AUTHENTICATION.html#Environment_Variables
+    #
+    # The environment variables that google-cloud-pubsub checks for project ID are:
+    # 1. PUBSUB_PROJECT
+    # 2. GOOGLE_CLOUD_PROJECT
+    #
+    # The environment variables that google-cloud-pubsub checks for credentials
+    # are configured on Google::Cloud::PubSub::V1::Credentials:
+    #
+    # 1. PUBSUB_CREDENTIALS - Path to JSON file, or JSON contents
+    # 2. PUBSUB_KEYFILE - Path to JSON file, or JSON contents
+    # 3. GOOGLE_CLOUD_CREDENTIALS - Path to JSON file, or JSON contents
+    # 4. GOOGLE_CLOUD_KEYFILE - Path to JSON file, or JSON contents
+    # 5. GOOGLE_APPLICATION_CREDENTIALS - Path to JSON file
+    def initialize_pubsub_client
+      @client = Google::Cloud::Pubsub.new
     end
 
-    def set_logger
+    def initialize_logger
       return use_rails_logger if rails_logger_exist?
       use_default_logger
     end
@@ -64,10 +76,12 @@ module Icalia::Event
 
     def use_rails_logger
       @logger = Rails.logger
+      GRPCRailsLogger.send :extend, GRPCRailsLogger
     end
 
     def use_default_logger
       @logger = ActiveSupport::Logger.new(STDOUT)
+      GRPCStdoutLogger.send :extend, GRPCStdoutLogger
     end
   end
 end

data/lib/icalia-sdk-event-notification/version.rb

@@ -2,6 +2,6 @@
 
 module Icalia
   module Event
-    NOTIFICATION_VERSION = '0.1.13'
+    NOTIFICATION_VERSION = '0.2.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: icalia-sdk-event-notification
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.2.0
 platform: ruby
 authors:
 - Roberto Quintanilla
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-24 00:00:00.000000000 Z
+date: 2020-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: icalia-sdk-event-core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.13
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.13
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -39,33 +39,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 5.2.0
 - !ruby/object:Gem::Dependency
-  name: aws-sdk-sns
+  name: google-cloud-pubsub
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.19'
+        version: '0.31'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.19'
-- !ruby/object:Gem::Dependency
-  name: aws-sdk-sqs
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.20'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.20'
+        version: '0.31'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -119,13 +105,6 @@ files:
 - lib/icalia-sdk-event-notification.rb
 - lib/icalia-sdk-event-notification/notification.rb
 - lib/icalia-sdk-event-notification/publisher.rb
-- lib/icalia-sdk-event-notification/shoryuken.rb
-- lib/icalia-sdk-event-notification/shoryuken/cli.rb
-- lib/icalia-sdk-event-notification/shoryuken/cli/base.rb
-- lib/icalia-sdk-event-notification/shoryuken/cli/runner.rb
-- lib/icalia-sdk-event-notification/shoryuken/cli/sqs.rb
-- lib/icalia-sdk-event-notification/shoryuken/worker.rb
-- lib/icalia-sdk-event-notification/shoryuken/worker_registry.rb
 - lib/icalia-sdk-event-notification/topic_message_processing.rb
 - lib/icalia-sdk-event-notification/version.rb
 homepage: https://github.com/IcaliaLabs/icalia-sdk-ruby

data/lib/icalia-sdk-event-notification/shoryuken.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Icalia::Event
-  module Shoryuken
-    autoload :Worker, 'icalia-sdk-event-notification/shoryuken/worker'
-    autoload :WorkerRegistry, 'icalia-sdk-event-notification/shoryuken/worker_registry'
-    autoload :CLI, 'icalia-sdk-event-notification/shoryuken/cli'
-  end
-end

data/lib/icalia-sdk-event-notification/shoryuken/cli.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Icalia::Event::Shoryuken
-  module CLI
-    autoload :Base,   'icalia-sdk-event-notification/shoryuken/cli/base'
-    autoload :Runner, 'icalia-sdk-event-notification/shoryuken/cli/runner'
-    autoload :SQS,    'icalia-sdk-event-notification/shoryuken/cli/sqs'
-  end
-end

data/lib/icalia-sdk-event-notification/shoryuken/cli/base.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Icalia::Event::Shoryuken::CLI
-  class Base < Thor
-    no_commands do
-      def print_table(entries)
-        column_sizes = print_columns_size(entries)
-
-        entries.map do |entry|
-          puts entry.map.with_index { |e, i| print_format_column(e, column_sizes[i]) }.join
-        end
-      end
-
-      def print_columns_size(entries)
-        column_sizes = Hash.new(0)
-
-        entries.each do |entry|
-          entry.each_with_index do |e, i|
-            e = e.to_s
-            column_sizes[i] = e.size if column_sizes[i] < e.size
-          end
-        end
-
-        column_sizes
-      end
-
-      def print_format_column(column, size)
-        size_with_padding = size + 4
-        column = column.to_s.ljust(size_with_padding)
-        column
-      end
-
-      def fail_task(msg, quit = true)
-        say "[FAIL] #{msg}", :red
-        exit(1) if quit
-      end
-    end
-  end
-end

data/lib/icalia-sdk-event-notification/shoryuken/cli/runner.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'thor'
-require 'aws-sdk-core'
-
-module Icalia::Event::Shoryuken::CLI
-  class Runner < Base
-    default_task :start
-
-    register Icalia::Event::Shoryuken::CLI::SQS,
-             'sqs',
-             'sqs COMMAND',
-             'SQS commands'
-
-    desc 'start', 'Starts shoryuken'
-    method_option :concurrency, aliases: '-c', type: :numeric, desc: 'Processor threads to use'
-    method_option :daemon,      aliases: '-d', type: :boolean, desc: 'Daemonize process'
-    method_option :queues,      aliases: '-q', type: :array,   desc: 'Queues to process with optional weights'
-    method_option :require,     aliases: '-r', type: :string,  desc: 'Dir or path of the workers'
-    method_option :timeout,     aliases: '-t', type: :numeric, desc: 'Hard shutdown timeout'
-    method_option :config,      aliases: '-C', type: :string,  desc: 'Path to config file'
-    method_option :config_file,                type: :string,  desc: 'Path to config file (backwards compatibility)'
-    method_option :rails,       aliases: '-R', type: :boolean, desc: 'Load Rails'
-    method_option :logfile,     aliases: '-L', type: :string,  desc: 'Path to logfile'
-    method_option :pidfile,     aliases: '-P', type: :string,  desc: 'Path to pidfile'
-    method_option :verbose,     aliases: '-v', type: :boolean, desc: 'Print more verbose output'
-    method_option :delay,       aliases: '-D', type: :numeric, desc: 'Number of seconds to pause fetching from an empty queue'
-    
-    def start
-      opts = options.to_h.symbolize_keys
-
-      say '[DEPRECATED] Please use --config instead of --config-file', :yellow if opts[:config_file]
-
-      opts[:config_file] = opts.delete(:config) if opts[:config]
-
-      # Keep compatibility with old CLI queue format
-      opts[:queues] = opts[:queues].reject(&:empty?).map { |q| q.split(',') } if opts[:queues]
-
-      fail_task "You should set a logfile if you're going to daemonize" if opts[:daemon] && opts[:logfile].nil?
-
-      Shoryuken::Runner.instance.run(opts.freeze)
-    end
-
-    desc 'version', 'Prints version'
-    def version
-      say "Shoryuken #{Shoryuken::VERSION}"
-    end
-  end
-end

data/lib/icalia-sdk-event-notification/shoryuken/cli/sqs.rb

@@ -1,214 +0,0 @@
-# frozen_string_literal: true
-
-require 'date'
-require 'aws-sdk-sqs'
-
-# rubocop:disable Metrics/BlockLength
-module Icalia::Event::Shoryuken::CLI
-  class SQS < Base
-    namespace :sqs
-
-    no_commands do
-      def normalize_dump_message(message)
-        # symbolize_keys is needed for keeping it compatible with `requeue`
-        attributes = message[:attributes].symbolize_keys
-        {
-          id: message[:message_id],
-          message_body: message[:body],
-          message_attributes: message[:message_attributes],
-          message_deduplication_id: attributes[:MessageDeduplicationId],
-          message_group_id: attributes[:MessageGroupId]
-        }
-      end
-
-      def sqs
-        @_sqs ||= Aws::SQS::Client.new Icalia::Event.sqs_client_options
-      end
-
-      def find_queue_url(queue_name)
-        sqs.get_queue_url(queue_name: queue_name).queue_url
-      rescue Aws::SQS::Errors::NonExistentQueue
-        fail_task "The specified queue #{queue_name} does not exist"
-      end
-
-      def batch_delete(url, messages)
-        messages.to_a.flatten.each_slice(10) do |batch|
-          sqs.delete_message_batch(
-            queue_url: url,
-            entries: batch.map { |message| { id: message.message_id, receipt_handle: message.receipt_handle } }
-          ).failed.any? do |failure|
-            say(
-              "Could not delete #{failure.id}, code: #{failure.code}, message: #{failure.message}, sender_fault: #{failure.sender_fault}",
-              :yellow
-            )
-          end
-        end
-      end
-
-      def batch_send(url, messages, messages_per_batch = 10)
-        messages.to_a.flatten.map(&method(:normalize_dump_message)).each_slice(messages_per_batch) do |batch|
-          sqs.send_message_batch(queue_url: url, entries: batch).failed.any? do |failure|
-            say "Could not requeue #{failure.id}, code: #{failure.code}", :yellow
-          end
-        end
-      end
-
-      def find_all(url, limit)
-        count = 0
-        batch_size = limit > 10 ? 10 : limit
-
-        loop do
-          n = limit - count
-          batch_size = n if n < batch_size
-
-          messages = sqs.receive_message(
-            queue_url: url,
-            max_number_of_messages: batch_size,
-            attribute_names: ['All'],
-            message_attribute_names: ['All']
-          ).messages
-
-          messages.each { |m| yield m }
-
-          count += messages.size
-
-          break if count >= limit
-          break if messages.empty?
-        end
-
-        count
-      end
-
-      def list_and_print_queues(urls)
-        attrs = %w[QueueArn ApproximateNumberOfMessages ApproximateNumberOfMessagesNotVisible LastModifiedTimestamp]
-
-        entries = urls.map { |u| sqs.get_queue_attributes(queue_url: u, attribute_names: attrs).attributes }.map do |q|
-          [
-            q['QueueArn'].split(':').last,
-            q['ApproximateNumberOfMessages'],
-            q['ApproximateNumberOfMessagesNotVisible'],
-            Time.at(q['LastModifiedTimestamp'].to_i)
-          ]
-        end
-
-        entries.unshift(['Queue', 'Messages Available', 'Messages Inflight', 'Last Modified'])
-
-        print_table(entries)
-      end
-
-      def dump_file(path, queue_name)
-        File.join(path, "#{queue_name}-#{Date.today}.jsonl")
-      end
-    end
-
-    desc 'ls [QUEUE-NAME-PREFIX]', 'Lists queues'
-    method_option :watch,    aliases: '-w', type: :boolean, desc: 'watch queues'
-    method_option :interval, aliases: '-n', type: :numeric, default: 2, desc: 'watch interval in seconds'
-    def ls(queue_name_prefix = '')
-      trap('SIGINT', 'EXIT') # expect ctrl-c from loop
-
-      urls = sqs.list_queues(queue_name_prefix: queue_name_prefix).queue_urls
-
-      loop do
-        list_and_print_queues(urls)
-
-        break unless options[:watch]
-
-        sleep options[:interval]
-        puts
-      end
-    end
-
-    desc 'dump QUEUE-NAME', 'Dumps messages from a queue into a JSON lines file'
-    method_option :number, aliases: '-n', type: :numeric, default: Float::INFINITY, desc: 'number of messages to dump'
-    method_option :path,   aliases: '-p', type: :string,  default: './',            desc: 'path to save the dump file'
-    method_option :delete, aliases: '-d', type: :boolean, default: true,            desc: 'delete from the queue'
-    def dump(queue_name)
-      path = dump_file(options[:path], queue_name)
-
-      fail_task "File #{path} already exists" if File.exist?(path)
-
-      url = find_queue_url(queue_name)
-
-      messages = []
-
-      file = nil
-
-      count = find_all(url, options[:number]) do |m|
-        file ||= File.open(path, 'w')
-
-        file.puts(JSON.dump(m.to_h))
-
-        messages << m if options[:delete]
-      end
-
-      batch_delete(url, messages) if options[:delete]
-
-      if count.zero?
-        say "Queue #{queue_name} is empty", :yellow
-      else
-        say "Dump saved in #{path} with #{count} messages", :green
-      end
-    ensure
-      file.close if file
-    end
-
-    desc 'requeue QUEUE-NAME PATH', 'Requeues messages from a dump file'
-    method_option :batch_size, aliases: '-n', type: :numeric, default: 10, desc: 'number of messages per batch to send'
-    def requeue(queue_name, path)
-      fail_task "Path #{path} not found" unless File.exist?(path)
-
-      messages = File.readlines(path).map { |line| JSON.parse(line, symbolize_names: true) }
-
-      batch_send(find_queue_url(queue_name), messages, options[:batch_size])
-
-      say "Requeued #{messages.size} messages from #{path} to #{queue_name}", :green
-    end
-
-    desc 'mv QUEUE-NAME-SOURCE QUEUE-NAME-TARGET', 'Moves messages from one queue (source) to another (target)'
-    method_option :number, aliases: '-n', type: :numeric, default: Float::INFINITY, desc: 'number of messages to move'
-    method_option :delete, aliases: '-d', type: :boolean, default: true,            desc: 'delete from the queue'
-    def mv(queue_name_source, queue_name_target)
-      url_source = find_queue_url(queue_name_source)
-      messages = []
-
-      count = find_all(url_source, options[:number]) do |m|
-        messages << m
-      end
-
-      batch_send(find_queue_url(queue_name_target), messages.map(&:to_h))
-      batch_delete(url_source, messages) if options[:delete]
-
-      if count.zero?
-        say "Queue #{queue_name_source} is empty", :yellow
-      else
-        say "Moved #{count} messages from #{queue_name_source} to #{queue_name_target}", :green
-      end
-    end
-
-    desc 'purge QUEUE-NAME', 'Deletes the messages in a queue'
-    def purge(queue_name)
-      sqs.purge_queue(queue_url: find_queue_url(queue_name))
-
-      say "Purge request sent for #{queue_name}. The message deletion process takes up to 60 seconds", :yellow
-    end
-
-    desc 'create QUEUE-NAME', 'Create a queue'
-    method_option :attributes, aliases: '-a', type: :hash, default: {}, desc: 'queue attributes'
-    def create(queue_name)
-      attributes = options[:attributes]
-      attributes['FifoQueue'] ||= 'true' if queue_name.end_with?('.fifo')
-
-      queue_url = sqs.create_queue(queue_name: queue_name, attributes: attributes).queue_url
-
-      say "Queue #{queue_name} was successfully created. Queue URL #{queue_url}", :green
-    end
-
-    desc 'delete QUEUE-NAME', 'delete a queue'
-    def delete(queue_name)
-      sqs.delete_queue(queue_url: find_queue_url(queue_name))
-
-      say "Queue #{queue_name} was successfully delete", :green
-    end
-  end
-end

data/lib/icalia-sdk-event-notification/shoryuken/worker.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Icalia::Event::Shoryuken
-  class Worker
-    include Shoryuken::Worker
-    include Icalia::Event::TopicMessageProcessing
-
-    shoryuken_options queue: 'icalia_events', auto_delete: true
-
-    delegate :logger, to: Shoryuken
-
-    # By default, process all notifications:
-    def process_notification?(notification); true; end
-
-    def perform(_sqs_msg, raw_notification)
-      notification = Icalia::Event::Notification.new raw_notification
-      
-      return unless process_notification?(notification)
-      
-      logger.info "Processing notification from topic"\
-                  " '#{notification.topic}'" #: #{notification.inspect}"
-      
-      # If there was no action (some events may not have an action!), we'll 
-      # run the `process_message` method instead:
-      action_name = notification.action || 'default'
-      send "process_#{action_name.underscore}".to_sym, notification
-    end
-
-    delegate :define_noop_action_processor, to: :class
-
-    class ActionProcessorPatternTest
-      attr_reader :action_name
-      
-      def initialize(method_sym)
-        if method_sym.to_s =~ /\Aprocess_(\w+)\z/
-          @action_name = $1.to_sym
-        end
-      end
-      
-      def match?; @action_name != nil; end
-    end
-
-    def method_missing(method_sym, *arguments, &block)
-      processor_test = ActionProcessorPatternTest.new(method_sym)
-      
-      if processor_test.match?
-        define_noop_action_processor(method_sym, processor_test.action_name)
-        return send(method_sym, *arguments)
-      end
-
-      super
-    end
-
-    def self.define_noop_action_processor(action_processor_method, action_name)
-      return if method_defined? action_processor_method
-      
-      define_method action_processor_method do |*args|
-        logger.info "#{self.class.name} does not know how to process " \
-                    "#{action_name} - Ignoring message"
-      end
-    end
-  end
-end

data/lib/icalia-sdk-event-notification/shoryuken/worker_registry.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Icalia::Event::Shoryuken
-  class WorkerRegistry < Shoryuken::DefaultWorkerRegistry
-    def fetch_worker(queue, message)
-      worker = super
-      return worker if worker.present?
-  
-      require_jobs if empty_mappings?
-  
-      topic_name = extract_topic_name(message)
-  
-      worker_class = Icalia::Event::TopicMessageProcessing
-        .worker_mappings[topic_name]
-      
-      return worker_class.new if worker_class.present?
-    end
-  
-    protected
-  
-    delegate :extract_topic_name, :require_jobs, to: :class
-    delegate :empty_mappings?, to: Icalia::Event::TopicMessageProcessing
-  
-    def self.require_jobs
-      path = Rails.root.join('app', 'jobs', '**', '*_job.rb')
-      Dir[path].each {|file| require file }
-    end
-  
-    def self.extract_topic_name(message)
-      extract_metadata(message)['topic_arn'].split(':')[5..-1].join(':')
-    end
-  
-    def self.extract_metadata(message)
-      extract_body(message)
-        .except('Message')
-        .transform_keys(&:underscore)
-        .with_indifferent_access
-    end
-  
-    def self.extract_body(message)
-      ActiveSupport::JSON.decode message.body
-    end
-  end
-end