cloudenvoy 0.1.0.dev → 0.4.0

data/lib/cloudenvoy/engine.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Cloudenvoy
+  # CLoudenvoy Rails engine
+  class Engine < ::Rails::Engine
+    isolate_namespace Cloudenvoy
+
+    initializer 'cloudenvoy', before: :load_config_initializers do
+      Rails.application.routes.append do
+        mount Cloudenvoy::Engine, at: '/cloudenvoy'
+      end
+    end
+
+    config.generators do |g|
+      g.test_framework :rspec, fixture: false
+      g.assets false
+      g.helper false
+    end
+  end
+end

data/lib/cloudenvoy/invalid_subscriber_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Cloudenvoy
+  class InvalidSubscriberError < StandardError
+  end
+end

data/lib/cloudenvoy/logger_wrapper.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Cloudenvoy
+  # Add contextual information to logs generated
+  # by subscribers/publishers.
+  #
+  # This class is a base class which aims at being inherited by
+  # object-specific logger wrappers. See Cloudenvoy::SubscriberLogger
+  # and Cloudenvoy::PublisherLogger.
+  class LoggerWrapper
+    attr_accessor :loggable
+
+    class << self
+      attr_accessor :log_context_processor
+    end
+
+    #
+    # The default context processor. Aims at being overriden by
+    # child classes.
+    #
+    # @return [Proc] The context processor proc.
+    #
+    def self.default_context_processor
+      @default_context_processor ||= ->(_) { {} }
+    end
+
+    #
+    # Build a new instance of the class.
+    #
+    # @param [Any] loggable The loggable to wrap for logging.
+    #
+    def initialize(loggable)
+      @loggable = loggable
+    end
+
+    #
+    # Return the Proc responsible for formatting the log payload.
+    #
+    # @return [Proc] The context processor.
+    #
+    def context_processor
+      @context_processor ||= loggable.class.cloudenvoy_options_hash[:log_context_processor] ||
+                             self.class.log_context_processor ||
+                             self.class.default_context_processor
+    end
+
+    #
+    # The block to pass to log messages.
+    #
+    # @return [Proc] The log block.
+    #
+    def log_block
+      @log_block ||= proc { context_processor.call(loggable) }
+    end
+
+    #
+    # Return the Cloudenvoy logger.
+    #
+    # @return [Logger, any] The cloudenvoy logger.
+    #
+    def logger
+      Cloudenvoy.logger
+    end
+
+    #
+    # Format main log message.
+    #
+    # @param [String] msg The message to log.
+    #
+    # @return [String] The formatted log message
+    #
+    def formatted_message(msg)
+      "[Cloudenvoy][#{loggable.class}] #{msg}"
+    end
+
+    #
+    # Log an info message.
+    #
+    # @param [String] msg The message to log.
+    # @param [Proc] &block Optional context block.
+    #
+    def info(msg, &block)
+      log_message(:info, msg, &block)
+    end
+
+    #
+    # Log an error message.
+    #
+    # @param [String] msg The message to log.
+    # @param [Proc] &block Optional context block.
+    #
+    def error(msg, &block)
+      log_message(:error, msg, &block)
+    end
+
+    #
+    # Log an fatal message.
+    #
+    # @param [String] msg The message to log.
+    # @param [Proc] &block Optional context block.
+    #
+    def fatal(msg, &block)
+      log_message(:fatal, msg, &block)
+    end
+
+    #
+    # Log an debut message.
+    #
+    # @param [String] msg The message to log.
+    # @param [Proc] &block Optional context block.
+    #
+    def debug(msg, &block)
+      log_message(:debug, msg, &block)
+    end
+
+    #
+    # Delegate all methods to the underlying logger.
+    #
+    # @param [String, Symbol] name The method to delegate.
+    # @param [Array<any>] *args The list of method arguments.
+    # @param [Proc] &block Block passed to the method.
+    #
+    # @return [Any] The method return value
+    #
+    def method_missing(name, *args, &block)
+      if logger.respond_to?(name)
+        logger.send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    #
+    # Check if the class respond to a certain method.
+    #
+    # @param [String, Symbol] name The name of the method.
+    # @param [Boolean] include_private Whether to check private methods or not. Default to false.
+    #
+    # @return [Boolean] Return true if the class respond to this method.
+    #
+    def respond_to_missing?(name, include_private = false)
+      logger.respond_to?(name) || super
+    end
+
+    private
+
+    #
+    # Log a message for the provided log level.
+    #
+    # @param [String, Symbol] level The log level
+    # @param [String] msg The message to log.
+    # @param [Proc] &block Optional context block.
+    #
+    def log_message(level, msg, &block)
+      # Merge log-specific context into object-specific context
+      payload_block = ->(*_args) { log_block.call.merge(block&.call || {}) }
+
+      # ActiveSupport::Logger does not support passing a payload through a block on top
+      # of a message.
+      if defined?(ActiveSupport::Logger) && logger.is_a?(ActiveSupport::Logger)
+        logger.send(level) { "#{formatted_message(msg)} -- #{payload_block.call}" }
+      else
+        logger.send(level, formatted_message(msg), &payload_block)
+      end
+    end
+  end
+end

data/lib/cloudenvoy/message.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Cloudenvoy
+  # Represents a Pub/Sub message
+  class Message
+    attr_writer :topic
+    attr_accessor :id, :payload, :metadata, :sub_uri
+
+    #
+    # Return an instantiated message from a Pub/Sub webhook
+    # payload.
+    #
+    # @param [Hash] input_payload The Pub/Sub webhook hash describing
+    # the message to process.
+    #
+    # @return [Cloudenvoy::Message] The instantiated message.
+    #
+    def self.from_descriptor(input_payload)
+      # Build new message
+      new(
+        id: input_payload.dig('message', 'message_id'),
+        payload: JSON.parse(Base64.decode64(input_payload.dig('message', 'data'))),
+        metadata: input_payload.dig('message', 'attributes'),
+        sub_uri: input_payload['subscription']
+      )
+    end
+
+    #
+    # Constructor
+    #
+    # @param [String] id The message ID
+    # @param [Hash, String] payload The message payload
+    # @param [Hash] metadata The message attributes
+    # @param [String] topic The topic - will be inferred from sub_uri if left blank
+    # @param [String] sub_uri The sub_uri this message was sent for
+    #
+    def initialize(id: nil, payload: nil, metadata: nil, topic: nil, sub_uri: nil)
+      @id = id
+      @payload = payload
+      @topic = topic
+      @metadata = metadata || {}
+      @sub_uri = sub_uri
+    end
+
+    #
+    # Return the message topic.
+    #
+    # @return [String] The message topic.
+    #
+    def topic
+      return @topic if @topic
+      return nil unless sub_uri
+
+      Subscriber.parse_sub_uri(sub_uri)[1]
+    end
+
+    #
+    # Return the instantiated Subscriber designated to process this message.
+    #
+    # @return [Subscriber] The instantiated subscriber.
+    #
+    def subscriber
+      @subscriber ||= begin
+        return nil unless sub_uri && (klass = Subscriber.from_sub_uri(sub_uri))
+
+        klass.new(message: self)
+      end
+    end
+
+    #
+    # Return a hash description of the message.
+    #
+    # @return [Hash] The message description
+    #
+    def to_h
+      {
+        id: id,
+        payload: payload,
+        metadata: metadata,
+        topic: topic,
+        sub_uri: sub_uri
+      }.compact
+    end
+
+    #
+    # Equality operator.
+    #
+    # @param [Any] other The object to compare.
+    #
+    # @return [Boolean] True if the object is equal.
+    #
+    def ==(other)
+      other.is_a?(self.class) && other.id == id
+    end
+  end
+end

data/lib/cloudenvoy/middleware/chain.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module Cloudenvoy
+  module Middleware
+    # The class below was originally taken from Sidekiq.
+    # See: https://github.com/mperham/sidekiq/blob/master/lib/sidekiq/middleware/chain.rb
+    #
+    # Middleware are callables configured to run before/after a message is processed.
+    # Middlewares can be configured to run on the client side (when jobs are pushed
+    # to Cloud Tasks) as well as on the server side (when jobs are processed by
+    # your application)
+    #
+    # To add a middleware on publishers:
+    #
+    # Cloudenvoy.configure do |config|
+    #   config.publisher_middleware do |chain|
+    #     chain.add MyPublisherHook
+    #   end
+    # end
+    #
+    # To modify middlewares on subscribers, just call
+    # with another block:
+    #
+    # Cloudenvoy.configure do |config|
+    #   config.subscriber_middleware do |chain|
+    #     chain.add MySubscriberHook
+    #     chain.remove ActiveRecord
+    #   end
+    # end
+    #
+    # To insert immediately preceding another entry:
+    #
+    # Cloudenvoy.configure do |config|
+    #   config.publisher_middleware do |chain|
+    #     chain.insert_before ActiveRecord, MyPublisherHook
+    #   end
+    # end
+    #
+    # To insert immediately after another entry:
+    #
+    # Cloudenvoy.configure do |config|
+    #   config.publisher_middleware do |chain|
+    #     chain.insert_after ActiveRecord, MyPublisherHook
+    #   end
+    # end
+    #
+    # This is an example of a minimal server middleware:
+    #
+    # class MySubscriberHook
+    #   def call(subscriber, msg, queue)
+    #     puts "Before work"
+    #     yield
+    #     puts "After work"
+    #   end
+    # end
+    #
+    # This is an example of a minimal client middleware, note
+    # the method must return the result or the job will not push
+    # to Redis:
+    #
+    # class MyPublisherHook
+    #   def call(publisher, msg, queue, redis_pool)
+    #     puts "Before push"
+    #     result = yield
+    #     puts "After push"
+    #     result
+    #   end
+    # end
+    #
+    class Chain
+      include Enumerable
+
+      #
+      # Build a new middleware chain.
+      #
+      def initialize
+        @entries = nil
+        yield self if block_given?
+      end
+
+      #
+      # Iterate over the list middlewares and execute the block on each item.
+      #
+      # @param [Proc] &block The block to execute on each item.
+      #
+      def each(&block)
+        entries.each(&block)
+      end
+
+      #
+      # Return the list of middlewares.
+      #
+      # @return [Array<Cloudenvoy::Middleware::Chain::Entry>] The list of middlewares
+      #
+      def entries
+        @entries ||= []
+      end
+
+      #
+      # Remove a middleware from the list.
+      #
+      # @param [Class] klass The middleware class to remove.
+      #
+      def remove(klass)
+        entries.delete_if { |entry| entry.klass == klass }
+      end
+
+      #
+      # Add a middleware at the end of the list.
+      #
+      # @param [Class] klass The middleware class to add.
+      # @param [Arry<any>] *args The list of arguments to the middleware.
+      #
+      # @return [Array<Cloudenvoy::Middleware::Chain::Entry>] The updated list of middlewares
+      #
+      def add(klass, *args)
+        remove(klass) if exists?(klass)
+        entries << Entry.new(klass, *args)
+      end
+
+      #
+      # Add a middleware at the beginning of the list.
+      #
+      # @param [Class] klass The middleware class to add.
+      # @param [Arry<any>] *args The list of arguments to the middleware.
+      #
+      # @return [Array<Cloudenvoy::Middleware::Chain::Entry>] The updated list of middlewares
+      #
+      def prepend(klass, *args)
+        remove(klass) if exists?(klass)
+        entries.insert(0, Entry.new(klass, *args))
+      end
+
+      #
+      # Add a middleware before another middleware.
+      #
+      # @param [Class] oldklass The middleware class before which the new middleware should be inserted.
+      # @param [Class] newklass The middleware class to insert.
+      # @param [Arry<any>] *args The list of arguments for the inserted middleware.
+      #
+      # @return [Array<Cloudenvoy::Middleware::Chain::Entry>] The updated list of middlewares
+      #
+      def insert_before(oldklass, newklass, *args)
+        i = entries.index { |entry| entry.klass == newklass }
+        new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+        i = entries.index { |entry| entry.klass == oldklass } || 0
+        entries.insert(i, new_entry)
+      end
+
+      #
+      # Add a middleware after another middleware.
+      #
+      # @param [Class] oldklass The middleware class after which the new middleware should be inserted.
+      # @param [Class] newklass The middleware class to insert.
+      # @param [Arry<any>] *args The list of arguments for the inserted middleware.
+      #
+      # @return [Array<Cloudenvoy::Middleware::Chain::Entry>] The updated list of middlewares
+      #
+      def insert_after(oldklass, newklass, *args)
+        i = entries.index { |entry| entry.klass == newklass }
+        new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+        i = entries.index { |entry| entry.klass == oldklass } || entries.count - 1
+        entries.insert(i + 1, new_entry)
+      end
+
+      #
+      # Checks if middleware has been added to the list.
+      #
+      # @param [Class] klass The middleware class to check.
+      #
+      # @return [Boolean] Return true if the middleware is in the list.
+      #
+      def exists?(klass)
+        any? { |entry| entry.klass == klass }
+      end
+
+      #
+      # Checks if the middlware list is empty
+      #
+      # @return [Boolean] Return true if the middleware list is empty.
+      #
+      def empty?
+        @entries.nil? || @entries.empty?
+      end
+
+      #
+      # Return a list of instantiated middlewares. Each middleware gets
+      # initialize with the args originally passed to `add`, `insert_before` etc.
+      #
+      # @return [Array<any>] The list of instantiated middlewares.
+      #
+      def retrieve
+        map(&:make_new)
+      end
+
+      #
+      # Empty the list of middlewares.
+      #
+      # @return [Array<Cloudenvoy::Middleware::Chain::Entry>] The updated list of middlewares
+      #
+      def clear
+        entries.clear
+      end
+
+      #
+      # Invoke the chain of middlewares.
+      #
+      # @param [Array<any>] *args The args to pass to each middleware.
+      #
+      def invoke(*args)
+        return yield if empty?
+
+        chain = retrieve.dup
+        traverse_chain = lambda do
+          if chain.empty?
+            yield
+          else
+            chain.shift.call(*args, &traverse_chain)
+          end
+        end
+        traverse_chain.call
+      end
+    end
+
+    # Middleware list item.
+    class Entry
+      attr_reader :klass, :args
+
+      #
+      # Build a new entry.
+      #
+      # @param [Class] klass The middleware class.
+      # @param [Array<any>] *args The list of arguments for the middleware.
+      #
+      def initialize(klass, *args)
+        @klass = klass
+        @args = args
+      end
+
+      #
+      # Return an instantiated middleware.
+      #
+      # @return [Any] The instantiated middleware.
+      #
+      def make_new
+        @klass.new(*@args)
+      end
+    end
+  end
+end