sbmt-strangler 0.9.1

data/lib/sbmt/strangler/configuration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    class Configuration
+      extend Sbmt::Strangler::Configurable
+
+      option :params_tracking_allowlist, :headers_allowlist, default: []
+      option :action_controller_base_class, default: "ActionController::Base"
+      option :error_tracker, default: "Sbmt::Strangler::ErrorTracker"
+      option :flipper_actor, default: ->(_http_params, _headers) {}
+
+      attr_reader :controllers, :http
+
+      def initialize(options = {})
+        @controllers = []
+        @http = ActiveSupport::InheritableOptions.new(Sbmt::Strangler::Http::DEFAULT_HTTP_OPTIONS)
+      end
+
+      def controller(name, &)
+        controllers.push(Sbmt::Strangler::Controller.new(name, self, &))
+      end
+    end
+  end
+end

data/lib/sbmt/strangler/const_definer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    class ConstDefiner
+      class << self
+        def call!(name, klass)
+          const_names = name.split("::")
+          class_name = const_names.pop
+          module_name = if const_names.any?
+            define_modules(const_names)
+          else
+            Object
+          end
+
+          module_name.const_set(class_name, klass)
+        end
+
+        private
+
+        def define_modules(module_names)
+          module_names.reduce(Object) do |parent_module_name, module_name|
+            define_module(module_name, parent_module_name)
+            "#{parent_module_name}::#{module_name}".constantize
+          end
+        end
+
+        def define_module(module_name, parent_module_name)
+          return if parent_module_name.const_defined?(module_name, false)
+
+          parent_module_name.const_set(module_name, Module.new)
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/strangler/controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    class Controller
+      extend Sbmt::Strangler::Configurable
+
+      option :params_tracking_allowlist, :headers_allowlist, :flipper_actor, default_from: :configuration
+
+      attr_reader :name, :class_name, :actions, :configuration
+
+      def initialize(name, configuration, &)
+        @name = name
+        @class_name = "#{name.camelize}Controller"
+        @actions = []
+        @configuration = configuration
+
+        yield(self)
+      end
+
+      def action(name, &)
+        @actions.push(Sbmt::Strangler::Action.new(name, self, &))
+      end
+
+      def http
+        @http ||= ActiveSupport::InheritableOptions.new(configuration.http)
+      end
+    end
+  end
+end

data/lib/sbmt/strangler/engine.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+
+module Sbmt
+  module Strangler
+    class Engine < Rails::Engine
+      isolate_namespace Sbmt::Strangler
+    end
+  end
+end

data/lib/sbmt/strangler/error_tracker.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    class ErrorTracker
+      class << self
+        def error(message, params = {})
+          unless defined?(Sentry)
+            Sbmt::Strangler.logger.log_error(message, params)
+            return
+          end
+
+          logging(:error, message, params)
+        end
+
+        private
+
+        def logging(level, message, params)
+          params = {message: params} if params.is_a?(String)
+
+          Sentry.with_scope do |scope|
+            scope.set_contexts(contexts: params)
+
+            if message.is_a?(Exception)
+              Sentry.capture_exception(message, level: level)
+            else
+              Sentry.capture_message(message, level: level)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/strangler/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    class ConfigurationError < StandardError; end
+  end
+end

data/lib/sbmt/strangler/feature_flags.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    class FeatureFlags
+      FLAGS = %i[
+        mirror
+        replace
+      ]
+      FEATURES_HEADER_NAME = "HTTP_STRANGLER_FEATURES"
+
+      attr_reader :strangler_action, :rails_controller
+
+      def initialize(strangler_action:, rails_controller: nil)
+        @strangler_action = strangler_action
+        @rails_controller = rails_controller
+      end
+
+      FLAGS.each do |flag_name|
+        define_method(:"#{flag_name}?") { feature_enabled?(feature_name(flag_name)) }
+      end
+
+      def add_all!
+        FLAGS.each { |flag_name| add(feature_name(flag_name)) }
+      end
+
+      private
+
+      delegate :add, :enabled?, :enabled_on_time?, to: "Sbmt::Strangler::Flipper"
+
+      FEATURE_NAME_SANITIZER = -> { _1.to_s.gsub(/[^A-Za-z0-9]+/, "-") }
+
+      def feature_name(flag_name)
+        sanitized_controller_name = FEATURE_NAME_SANITIZER.call(strangler_action.controller.name)
+        sanitized_action_name = FEATURE_NAME_SANITIZER.call(strangler_action.name)
+        sanitized_flag_name = FEATURE_NAME_SANITIZER.call(flag_name)
+
+        "#{sanitized_controller_name}__#{sanitized_action_name}--#{sanitized_flag_name}"
+      end
+
+      def feature_enabled?(feature_name)
+        enabled?(feature_name, flipper_actor) ||
+          enabled_on_time?(feature_name) ||
+          enabled_by_header?(feature_name)
+      end
+
+      def flipper_actor
+        @flipper_actor ||= strangler_action.flipper_actor.call(rails_controller.http_params, rails_controller.request.headers)
+      end
+
+      def enabled_by_header?(feature_name)
+        features = rails_controller.request.headers[FEATURES_HEADER_NAME]
+        return false unless features.present? && features.is_a?(String)
+
+        features.split(",").map(&:strip).include?(feature_name)
+      end
+    end
+  end
+end

data/lib/sbmt/strangler/flipper.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    module Flipper
+      FLIPPER_ID_STRUCT = Struct.new(:flipper_id)
+      ONTIME_ACTOR_REGEXP = /^ONTIME:(\d{2})-(\d{2})$/
+
+      class << self
+        delegate :add, to: ::Flipper
+
+        def enabled?(feature_name, *actors)
+          raise "feature name is blank" if feature_name.blank?
+
+          actors = Array(actors).flatten.compact
+          ::Flipper.enabled?(feature_name, *actors.map { FLIPPER_ID_STRUCT.new(_1) })
+        end
+
+        def enabled_on_time?(feature_name)
+          raise "feature name is blank" if feature_name.blank?
+
+          hours_ranges =
+            ::Flipper[feature_name]
+              .actors_value
+              .filter_map { |e|
+                e.match(ONTIME_ACTOR_REGEXP) {
+                  $LAST_MATCH_INFO.captures.map(&:to_i)
+                }
+              }
+              .compact
+
+          hour_now = DateTime.now.in_time_zone.hour
+          hours_ranges.any? { |range| (range.first..range.last).cover?(hour_now) }
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/strangler/http/client.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    module Http
+      class Client
+        include Dry::Monads::Result::Mixin
+
+        def initialize(http_options: nil)
+          @http_options = http_options
+        end
+
+        def call(url, http_verb, payload: {}, headers: {})
+          case http_verb.downcase
+          when :get
+            transport.get_request(url, params: payload, headers: prepare_headers(headers))
+          when :post
+            transport.post_request(url, body: payload, headers: prepare_headers(headers))
+          when :put
+            transport.put_request(url, body: payload, headers: prepare_headers(headers))
+
+          else
+            raise "unsupported http verb - #{http_verb}"
+          end
+        end
+
+        private
+
+        attr_reader :http_options
+
+        def transport
+          @transport ||= Sbmt::Strangler::Http::Transport.new(http_options: http_options)
+        end
+
+        def prepare_headers(headers)
+          headers&.transform_keys { |key| key.sub("HTTP_", "").tr("_", "-") }
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/strangler/http/transport.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    module Http
+      class Transport
+        include Dry::Monads::Do
+        include Dry::Monads::Result::Mixin
+
+        def initialize(http_options: nil)
+          @http_options = http_options
+        end
+
+        def get_request(url, params: {}, headers: {})
+          with_error_handling(url) do
+            response = connection.get(url, params, headers)
+            Success(body: response.body, status: response.status, headers: response.headers)
+          end
+        end
+
+        def post_request(url, body: {}, headers: {})
+          with_error_handling(url) do
+            response = connection.post(url, body, headers)
+            Success(body: response.body, status: response.status, headers: response.headers)
+          end
+        end
+
+        def put_request(url, body: {}, headers: {})
+          with_error_handling(url) do
+            response = connection.put(url, body, headers)
+            Success(body: response.body, status: response.status, headers: response.headers)
+          end
+        end
+
+        private
+
+        attr_reader :http_options
+
+        def connection
+          @connection ||= Faraday.new do |conn|
+            conn.response :raise_error
+            Sbmt::Strangler::Http.configure_faraday(conn, name: "strangler_http_client", http_options: http_options)
+            # Skip JSON parsing because
+            #   1. it speeds up proxy mode and
+            #   2. allows us to duplicate proxy response easily.
+            # conn.response :json
+            conn.request :json
+          end
+        end
+
+        def with_error_handling(url)
+          retry_count ||= 0
+
+          yield
+        rescue Faraday::ConnectionFailed => error
+          Sbmt::Strangler.logger.error(
+            message: "Sbmt::Strangler::Http::Transport ConnectionFailed",
+            url: url,
+            attempt: retry_count + 1,
+            retries_count: http_options.retries_count
+          )
+
+          retry if (retry_count += 1) && retry_count <= http_options.retries_count
+
+          Failure(status: :bad_gateway)
+        rescue Faraday::UnprocessableEntityError, Faraday::ForbiddenError => error
+          Failure(body: error.response_body, status: error.response_status, headers: error.response_headers)
+        rescue Faraday::TimeoutError
+          Sbmt::Strangler.logger.error(
+            message: "Sbmt::Strangler::Http::Transport TimeoutError",
+            url: url
+          )
+          Failure(status: :gateway_timeout)
+        rescue Faraday::Error => error
+          response = error.response
+          Sbmt::Strangler.logger.error(error.message)
+          Sbmt::Strangler.error_tracker.error(error)
+          return Failure(status: :internal_server_error) unless response
+
+          Failure(body: response[:body], status: response[:status], headers: response[:headers])
+        rescue => error
+          Sbmt::Strangler.logger.error(error.message)
+          Sbmt::Strangler.error_tracker.error(error)
+          Failure(status: :internal_server_error)
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/strangler/http.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "http/client"
+require_relative "http/transport"
+
+module Sbmt
+  module Strangler
+    module Http
+      DEFAULT_HTTP_OPTIONS = {
+        keepalive_pool_size: 256,
+        keepalive_idle_timeout: 30,
+        timeout: 5,
+        read_timeout: 5,
+        write_timeout: 5,
+        open_timeout: 1,
+        retries_count: 1
+      }.freeze
+      REQUEST_PATH_FILTER_REGEX = %r{(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})|(/\d+)|(/[A-Z]\d{9,11}(-\d{1})?)}
+
+      # Configures Faraday connection. Sets default options and adds default middlewares into chain.
+      # Accepts an optional block to configure net-http-persistent-adapter
+      #
+      # @example
+      #
+      #   @conn ||= Faraday.new(@base_url) do |f|
+      #     Sbmt::Strangler::Http.configure_faraday(f, name: "http-client") do |http|
+      #       http.idle_timeout = 42
+      #     end
+      #     f.timeout = 5
+      #     f.response :json
+      #   end
+      #
+      # @param [Faraday::Connection] conn
+      # @param [Hash] opts faraday & middlewares options
+      # @option opts [String] :name client name for tracing and instrumentation. Required.
+      # @option opts [Hash] :adapter_opts net_http_persistent adapter options
+      # @option opts [ActiveSupport::InheritableOptions] :http_options timeout options
+      # @option opts [Regexp] :request_path_filter_regex (REQUEST_PATH_FILTER_REGEX) regex for filtering out
+      #                       variables from http request metric `path` tag. Set to false to add empty value instead.
+      #
+      # @return [Faraday::Connection]
+      def self.configure_faraday(conn, opts = {})
+        raise ConfigurationError, "Faraday client :name must be set" unless opts[:name]
+
+        http_options = opts[:http_options] || Sbmt::Strangler.configuration.http
+
+        conn.options.timeout = http_options.timeout
+        conn.options.read_timeout = http_options.read_timeout
+        conn.options.open_timeout = http_options.open_timeout
+        conn.options.write_timeout = http_options.write_timeout
+
+        configure_faraday_metrics(conn, opts.slice(:name, :request_path_filter_regex))
+
+        adapter_opts = {pool_size: http_options.keepalive_pool_size}.merge(opts[:adapter_opts] || {})
+        conn.adapter :net_http_persistent, adapter_opts do |http|
+          http.idle_timeout = http_options.keepalive_idle_timeout
+          yield http if block_given?
+        end
+
+        conn
+      end
+
+      def self.configure_faraday_metrics(conn, opts = {})
+        @subscribers ||= {}
+        name = opts.fetch(:name)
+        instrument_full_name = ["request.faraday", name].compact.join(".")
+        filter = opts.fetch(:request_path_filter_regex, REQUEST_PATH_FILTER_REGEX)
+
+        conn.request :instrumentation, name: instrument_full_name
+        return if @subscribers[instrument_full_name]
+
+        @subscribers[instrument_full_name] = ActiveSupport::Notifications.subscribe(instrument_full_name) do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          env = event.payload
+
+          tags = {
+            name: name,
+            method: env.method,
+            status: env.status || :error,
+            host: env.url.host,
+            path: filter ? env.url.path.gsub(filter, "/:id") : ""
+          }
+
+          Yabeda.sbmt_strangler.http_request_duration.measure(tags, event.duration.fdiv(1000))
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/strangler/logger.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    class Logger
+      delegate :logger, to: :Rails
+      delegate_missing_to :logger
+
+      def log_debug(message, **params)
+        with_tags(**params) do
+          logger.debug(message)
+        end
+      end
+
+      def log_info(message, **params)
+        with_tags(**params) do
+          logger.info(message)
+        end
+      end
+
+      def log_warn(message, **params)
+        with_tags(**params) do
+          logger.warn(message)
+        end
+      end
+
+      def log_error(message, **params)
+        with_tags(**params) do
+          logger.error(message)
+        end
+      end
+
+      def log_success(message, **params)
+        log_info(message, status: "success", **params)
+      end
+
+      def log_failure(message, **params)
+        log_error(message, status: "failure", **params)
+      end
+
+      def with_tags(**params)
+        logger.tagged(**params) do
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/strangler/metric_tracker.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    class MetricTracker
+      attr_reader :rails_controller
+
+      def initialize(rails_controller)
+        @rails_controller = rails_controller
+      end
+
+      def track_params_usage
+        ::Yabeda.sbmt_strangler.params_usage.increment(common_tags)
+      end
+
+      def log_unallowed_params
+        unallowed_params = all_request_params - allowed_request_params
+        Sbmt::Strangler.logger.log_warn(<<~WARN.strip) if unallowed_params.any?
+          Not allowed parameters in #{controller_path}##{action_name}: #{unallowed_params}
+        WARN
+      end
+
+      def track_work_mode(mode)
+        yabeda_tags = common_tags.merge(mode: mode.to_s)
+        ::Yabeda.sbmt_strangler.work_mode.increment(yabeda_tags)
+      end
+
+      def track_mirror_call(success)
+        yabeda_tags = common_tags.merge(success: success.to_s)
+        ::Yabeda.sbmt_strangler.mirror_call.increment(yabeda_tags)
+      end
+
+      def track_compare_call(success)
+        yabeda_tags = common_tags.merge(success: success.to_s)
+        ::Yabeda.sbmt_strangler.compare_call.increment(yabeda_tags)
+      end
+
+      def track_compare_call_result(value)
+        yabeda_tags = common_tags.merge(value: value.to_s)
+        ::Yabeda.sbmt_strangler.compare_call_result.increment(yabeda_tags)
+      end
+
+      def track_render_call(success)
+        yabeda_tags = common_tags.merge(success: success.to_s)
+        ::Yabeda.sbmt_strangler.render_call.increment(yabeda_tags)
+      end
+
+      private
+
+      delegate :http_params, :allowed_params, :controller_path, :action_name, to: :rails_controller
+
+      def common_tags
+        {
+          params: allowed_request_params.join(","),
+          controller: controller_path,
+          action: action_name
+        }
+      end
+
+      def allowed_request_params
+        @allowed_request_params ||= allowed_params.keys.map(&:to_s).sort.uniq
+      end
+
+      def all_request_params
+        @all_request_params ||= http_params.keys.map(&:to_s).sort.uniq
+      end
+    end
+  end
+end

data/lib/sbmt/strangler/mixin.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    module Mixin
+      attr_reader :strangler_action
+
+      def http_params
+        params.to_unsafe_h.except(:action, :controller, :format)
+      end
+
+      def allowed_params
+        return http_params if strangler_action.params_tracking_allowlist.blank?
+
+        params.permit(*strangler_action.params_tracking_allowlist).to_h
+      end
+
+      def allowed_headers
+        if strangler_action.headers_allowlist.blank?
+          return request.headers.select { |name, _| name.starts_with?("HTTP_") }.to_h
+        end
+
+        request.headers.select { |name, _| name.in?(strangler_action.headers_allowlist) }.to_h
+      end
+
+      def http_request(payload)
+        strangler_action.http_client.call(
+          proxy_url,
+          strangler_action.proxy_http_method,
+          payload: payload,
+          headers: allowed_headers
+        )
+      end
+
+      def proxy_url
+        case strangler_action.proxy_url
+        in String => url
+          url
+        in Proc => proc
+          proc.call(http_params, request.headers)
+        end
+      end
+
+      def render_origin_response(response)
+        if response.success?
+          body, status = response.value!.values_at(:body, :status)
+          render json: body, status: status
+          return
+        end
+
+        body, status = response.failure.values_at(:body, :status)
+        render json: body, status: status
+      end
+    end
+  end
+end

data/lib/sbmt/strangler/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    VERSION = "0.9.1"
+  end
+end

data/lib/sbmt/strangler/work_modes/base.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    module WorkModes
+      class Base
+        attr_reader :rails_controller, :strangler_action, :metric_tracker, :feature_flags
+
+        def initialize(rails_controller:, strangler_action:, metric_tracker:, feature_flags:)
+          @rails_controller = rails_controller
+          @strangler_action = strangler_action
+          @metric_tracker = metric_tracker
+          @feature_flags = feature_flags
+        end
+
+        def call
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end