sbmt-strangler 0.9.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e9bb8754c88d1b03e5d4a32bc244c6e14351d0e875dfd12bbf9011cb08c450ce
+  data.tar.gz: 3ac98da59470beb7f2d023352072bc589867e5af9d2160d07a805529577e7482
+SHA512:
+  metadata.gz: e1d13adacfa0630878515a07ae6619ddd23d2182a1fb17183be233ef7c10e0552c8917404d9728961e2fc14d0aa68131c328245b111465a56370a6d8e3d87086
+  data.tar.gz: 405bf3d3146936259e97aeb52f6d0a5065d5080be4891b9cff97463fde3df32a6d998a5b1b023b630b1e1fc4c35dc353384dfcf09431f9549d7e641cd065ef69

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--require rails_helper

data/.rubocop.yml

@@ -0,0 +1,54 @@
+inherit_from: .rubocop_todo.yml
+
+# We want Exclude directives from different
+# config files to get merged, not overwritten
+inherit_mode:
+  merge:
+    - Exclude
+
+AllCops:
+  TargetRubyVersion: 3.3
+  TargetRailsVersion: 7.1
+  NewCops: enable
+  SuggestExtensions: false
+
+require:
+  # Performance cops are bundled with Standard
+  - rubocop-performance
+  - rubocop-rails
+  - rubocop-rspec
+  # Standard's config uses custom cops,
+  # so it must be loaded
+  - standard
+
+inherit_gem:
+  standard: config/base.yml
+
+# rubocop-rails
+Rails/SkipsModelValidations:
+  Enabled: false
+
+# rubocop-rspec
+RSpec/AnyInstance:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/LetSetup:
+  Enabled: false
+
+RSpec/StubbedMock:
+  Enabled: false
+
+RSpec/MessageSpies:
+  Enabled: false
+
+RSpec/NestedGroups:
+  Max: 10
+
+RSpec/ExampleLength:
+  Max: 35
+
+RSpec/MultipleMemoizedHelpers:
+  Max: 15

data/Appraisals

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# See compatibility table at https://www.fastruby.io/blog/ruby/rails/versions/compatibility-table.html
+
+versions_map = {
+  "7.0" => %w[3.1],
+  "7.1" => %w[3.2 3.3]
+}
+
+current_ruby_version = RUBY_VERSION.split(".").first(2).join(".")
+
+versions_map.each do |rails_version, ruby_versions|
+  ruby_versions.each do |ruby_version|
+    next if ruby_version != current_ruby_version
+
+    appraise "railties-#{ruby_version}-#{rails_version}" do
+      gem "railties", "~> #{rails_version}.0"
+    end
+  end
+end

data/CHANGELOG.md

@@ -0,0 +1,106 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).
+
+## [0.9.1] - 2024-07-02
+
+### Added
+- Add put request support
+
+## [0.9.0] - 2024-06-06
+
+### Added
+- Add handler for Faraday::ConnectionFailed
+- Add retry connection support
+
+## [0.8.0] - 2024-06-05
+
+### Added
+- Add `action.render = ->(mirror_result) { ... }` lambda
+
+## [0.7.0] - 2024-06-03
+
+### Added
+- allow to configure timeout per route
+
+### Changed
+- rename "proxy_http_verb" to "proxy_http_method"
+
+## [0.6.0] - 2024-05-30
+
+### Added
+- add support for enabling work mode by request header
+
+## [0.5.0] - 2024-05-22
+
+### Added
+- use [net_http_persistent](https://github.com/lostisland/faraday-net_http_persistent) for proxying
+
+## [0.4.0] - 2024-05-22
+
+### Added
+- enable replace mode (it was temporarily commented out in the source code)
+- in the replace mode a value returned from action.mirror block is passed directly to the #render method
+- action.flipper_actor lambda can now return an array of actor IDs instead of a single actor ID
+
+### Changed
+- automatic feature flags name now has BEM-like formatting: "controller-path__action-name--work-mode" (because of Flipper UI limitations/recomendations)
+- action.compare is called for failed origin/proxy responses too
+- the first argument of action.compare block (called origin_result) is a hash of the form {body:, status:, headers:}
+- metric renamed: sbmt_strangler_compare_result -> sbmt_strangler_compare_call_result
+
+## [0.3.1] - 2024-04-24
+
+### Fixed
+- Create feature flags after the app fully initialized and handle flag creation errors
+
+## [0.3.0] - 2024-04-22
+
+### Added
+- add support for mirror and replace modes
+- add config options: action.mirror, action.compare, configuration.flipper_actor
+- add to Mixin: #track_mirror_call, #track_compare_call, #track_compare_result
+
+### Changed
+- rename Mixin#render_proxy_response to Mixin#render_origin_response
+- rename Mixin#track_work_tactic to Mixin#track_work_mode
+- Sbmt::Strangler::Http::Transport#get|post_request returns response body as String (it skips parsing body as JSON).
+
+### Fixed
+- Fix from v0.2.2 ported to v0.3.0
+
+## [0.2.2] - 2024-04-19
+
+### Fixed
+- filter out IDs like 'R608473650' from Faraday metric 'path' tag
+
+## [0.2.0] - 2024-04-09
+
+### Added
+- add metrics for http client request
+
+### Changed
+
+### Fixed
+
+## [0.1.1] - 2024-04-08
+
+### Added
+
+### Changed
+
+### Fixed
+- ignore inherit constants in Sbmt::Strangler::ConstDefiner
+
+## [0.1.0] - 2024-04-05
+
+### Added
+- initial release with proxy tooling
+
+### Changed
+
+### Fixed
+- ignore inherit constants in Sbmt::Strangler::ConstDefiner

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 SberMarket Tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,86 @@
+# Sbmt-strangler
+
+Sbmt-strangler is an implementation of Strangler-pattern for replacing legacy system http endpoints with three stages: proxying, mirroring, replacing.
+
+## Strangler Pattern
+
+[The strangler pattern](https://microservices.io/patterns/refactoring/strangler-application.html) is a software design and architectural pattern used in the context of legacy system modernization or application migration. The pattern’s name comes from the way certain plants, like strangler figs, grow around host trees, eventually replacing or “strangling” them entirely. Similarly, the Strangler Pattern aims to replace or evolve an existing system gradually, without causing any significant disruptions to the overall system functionality.
+
+## Features
+
+ - **Automatic proxying**: with help of DSL, the proxying algorithm is effortlessly implemented. A Rails controller and a proxying client are dynamically created. All you need to provide is the processed URL and the address of the original service (refine Rails route is also necessary).
+ - **Observability** - a comprehensive observability suite, with native support for [OpenTelementry](https://github.com/open-telemetry/opentelemetry-ruby), alongside proxy metrics based on the [Yabeda](https://github.com/yabeda-rb/yabeda) framework.
+ - **Smooth Mode Switching** allows you to safely and smoothly switch between modes using the [Flipper](https://github.com/flippercloud/flipper)-based feature flags.
+ - **Mirroring mode metrics** aid in tracking the accuracy and completeness of transferring business logic to a new service by comparing responses from both the legacy system and the new service.
+
+# Usage
+
+## Proxying
+
+*Proxying* mode is a setup where traffic destined for the legacy system is first routed through the service, only to be fully redirected back to the legacy system. While the service doesn't offer any extra functionalities, it does gain control over the traffic, allowing for future replacements.
+
+![Proxy-mode](docs/img/01-proxy_mode.png).
+
+To determine the proxy mode, you need to:
+
+1. Set the service path in the Rails controller, which will be generated automatically.
+2. Specify the path to the legacy system and the HTTP verbs used.
+3. Optionally, define a whitelist of proxied HTTP headers, as business logic can depend on them (original params & headers are available)
+
+ ```ruby
+ Sbmt::Strangler.configure do |strangler|
+  strangler.controller("api/hello") do |controller|
+    controller.headers_allowlist = %w[HTTP_API_VERSION HTTP_USER_AGENT HTTP_X_REQUEST_ID]
+    controller.params_tracking_allowlist = %w[name surname]
+
+    controller.action("index") do |action|
+      action.proxy_url = "http://example.com:8080/api/hello"
+      action.proxy_http_method = :post
+    end
+  end
+ ```
+
+## Mirroring
+
+*Mirroring* is an approach where requests are simultaneously processed by both the service and the monolith. The outcomes are then compared to calculate an accuracy metric, enabling timely monitoring of the service's endpoint performance. Importantly, the client receives the result from the monolith, ensuring that mirroring does not affect user experience.
+
+![Mirror-mode](docs/img/02-mirror_mode.png).
+
+To determine the mirroring mode, it is necessary to describe the business logic of the endpoint which will run in parallel with the request's proxying in the legacy system. Depending on the result, the success/failure metric of the mirroring logic will be logged.
+
+The mirroring mode involves comparing the results of the response from the legacy system with the results of calculations from the new implementation. To make this comparison, it is necessary to describe the corresponding lambda (compare).
+
+ ```ruby
+Sbmt::Strangler.configure do |strangler|
+  strangler.controller("api/hello") do |controller|
+    controller.headers_allowlist = %w[HTTP_API_VERSION HTTP_USER_AGENT HTTP_X_REQUEST_ID]
+    controller.params_tracking_allowlist = %w[name surname]
+
+    controller.action("index") do |action|
+      action.proxy_url = "http://example.com:8080/api/hello"
+      action.proxy_http_method = :post
+
+      # new implementation of legacy system business logic
+      action.mirror = ->(rails_controller) do
+        name, surname = rails_controller.params.values_at(:name, :surname)
+        {json: {greeting: "Hello, #{name} #{surname}!"}}
+      end
+
+      # compare legacy system response and mirror lambda calculation result
+      action.compare = ->(origin_result, mirror_result) do
+        origin_result[:status] == 200 &&
+          JSON.parse(origin_result[:body]) == mirror_result[:json]
+      end
+    end
+  end
+end
+ ```
+
+## Replacement
+
+*Replacement* refers to the process of substituting the functionality of a legacy system with a new implementation. In this scenario, the legacy system can either be completely removed from the framework or utilized to enhance the response outcomes of the new service.
+
+ ![Replace-mode](docs/img/03-replace_mode.png).
+
+
+To enable replacement mode, use the feature flag. Replacement mode uses mirror lambda for replacement logic.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/config/initializers/strangler.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Rails.application.config.after_initialize do
+  Sbmt::Strangler::Builder.call!
+end

data/config/initializers/yabeda.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    module Metrics
+      module Yabeda
+        HTTP_BUCKETS = [0.01, 0.02, 0.04, 0.1, 0.2, 0.5, 0.8, 1, 1.5, 2, 5, 15, 30, 60].freeze
+
+        ::Yabeda.configure do
+          group :sbmt_strangler do
+            histogram :http_request_duration,
+              tags: %i[name method status host path],
+              unit: :seconds,
+              buckets: HTTP_BUCKETS,
+              comment: "HTTP client request duration"
+
+            counter :params_usage,
+              comment: "Parameters usage counter",
+              tags: %i[params controller action]
+            counter :work_mode,
+              comment: "Work mode counter (mode: proxy, mirror, replace)",
+              tags: %i[mode params controller action]
+            counter :mirror_call,
+              comment: "Mirror lambda call counter (success: true, false)",
+              tags: %i[success params controller action]
+            counter :compare_call,
+              comment: "Compare lambda call counter (success: true, false)",
+              tags: %i[success params controller action]
+            counter :compare_call_result,
+              comment: "Compare lambda call result counter (value: true, false)",
+              tags: %i[value params controller action]
+            counter :render_call,
+              comment: "Render lambda call counter (success: true, false)",
+              tags: %i[success params controller action]
+          end
+        end
+      end
+    end
+  end
+end

data/dip.yml

@@ -0,0 +1,67 @@
+version: '7'
+
+environment:
+  RUBY_VERSION: '3.3'
+
+compose:
+  files:
+    - docker-compose.yml
+
+interaction:
+  bash:
+    description: Open the Bash shell in app's container
+    service: ruby
+    command: /bin/bash
+
+  bundle:
+    description: Run Bundler commands
+    service: ruby
+    command: bundle
+
+  rails:
+    description: Run RoR commands
+    service: ruby
+    command: bundle exec rails
+
+  appraisal:
+    description: Run Appraisal commands
+    service: ruby
+    command: bundle exec appraisal
+
+  swaggerize:
+    description: Build swagger docs
+    service: ruby
+    environment:
+      RAILS_ENV: test
+    command: bundle exec rspec --format Rswag::Specs::SwaggerFormatter --order defined spec/requests/
+
+  rspec:
+    description: Run Rspec commands
+    service: ruby
+    command: bundle exec rspec
+    subcommands:
+      all:
+        command: bundle exec appraisal rspec
+      rails-6.1:
+        command: bundle exec appraisal rails-6.1 rspec
+      rails-7.0:
+        command: bundle exec appraisal rails-7.0 rspec
+      rails-7.1:
+        command: bundle exec appraisal rails-7.1 rspec
+
+  rubocop:
+    description: Run Ruby linter
+    service: ruby
+    command: bundle exec rubocop
+
+  setup:
+    description: Install deps
+    service: ruby
+    command: bin/setup
+
+provision:
+  - dip compose down --volumes
+  - cp -f lefthook-local.dip_example.yml lefthook-local.yml
+  - rm -f Gemfile.lock
+  - rm -f gemfiles/*gemfile*
+  - dip setup

data/docker-compose.yml

@@ -0,0 +1,19 @@
+services:
+  ruby:
+    image: ${RUBY_DOCKER_IMAGE:-ruby}:${RUBY_VERSION:-3.3}
+    environment:
+      HISTFILE: /app/tmp/.bash_history
+      BUNDLE_PATH: /usr/local/bundle
+      BUNDLE_CONFIG: /app/.bundle/config
+      prometheus_multiproc_dir: ./tmp
+    command: bash
+    working_dir: /app
+    volumes:
+      - .:/app:cached
+      - ${RUBYGEMS_PATH:-..}:/app/vendor/gems:cached
+      - bundler_data:/usr/local/bundle
+    tmpfs:
+      - /tmp
+
+volumes:
+  bundler_data:

data/lefthook-local.dip_example.yml

@@ -0,0 +1,4 @@
+pre-commit:
+  commands:
+    rubocop:
+      run: dip {cmd}

data/lefthook.yml

@@ -0,0 +1,6 @@
+pre-commit:
+  commands:
+    rubocop:
+      tags: backend
+      glob: "{*.rb,**/*.rb,Gemfile,Rakefile}"
+      run: bundle exec rubocop -A --force-exclusion {staged_files} && git add {staged_files}

data/lib/sbmt/strangler/action.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    class Action
+      extend Sbmt::Strangler::Configurable
+
+      option :params_tracking_allowlist, :headers_allowlist, :flipper_actor, default_from: :controller
+      option :proxy_url
+      option :proxy_http_method, default: :get
+      option :mirror, default: ->(_rails_controller) {}
+      option :compare, default: ->(_origin_result, _mirror_result) { false }
+      option :render, default: ->(mirror_result) { mirror_result }
+
+      attr_reader :name, :controller
+
+      def initialize(name, controller, &)
+        @name = name
+        @controller = controller
+
+        yield(self)
+      end
+
+      def full_name
+        "#{controller.name}##{name}"
+      end
+
+      def http
+        @http ||= ActiveSupport::InheritableOptions.new(controller.http)
+      end
+
+      def http_client
+        @http_client ||= Sbmt::Strangler::Http::Client.new(http_options: http)
+      end
+    end
+  end
+end

data/lib/sbmt/strangler/action_invoker.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    class ActionInvoker
+      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
+
+      delegate :track_params_usage, :track_work_mode, :log_unallowed_params, to: :metric_tracker
+
+      def call
+        track_params_usage
+        log_unallowed_params
+        track_work_mode(work_mode_class.name.demodulize.underscore)
+        work_mode_class.new(
+          rails_controller:,
+          strangler_action:,
+          metric_tracker:,
+          feature_flags:
+        ).call
+      end
+
+      private
+
+      def work_mode_class
+        @work_mode_class ||=
+          if feature_flags.replace?
+            Sbmt::Strangler::WorkModes::Replace
+          elsif feature_flags.mirror?
+            Sbmt::Strangler::WorkModes::Mirror
+          else
+            Sbmt::Strangler::WorkModes::Proxy
+          end
+      end
+    end
+  end
+end

data/lib/sbmt/strangler/builder.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    class Builder
+      attr_reader :configuration
+
+      # @param configuration [Sbmt::Strangler::Configuration]
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def call!
+        build_controllers
+        add_feature_flags
+      end
+
+      def self.call!(configuration = Sbmt::Strangler.configuration)
+        new(configuration).call!
+      end
+
+      private
+
+      def build_controllers
+        configuration.controllers.each do |controller|
+          unless Object.const_defined?(controller.class_name)
+            Sbmt::Strangler::ConstDefiner.call!(controller.class_name, Class.new(Sbmt::Strangler.action_controller_base_class))
+          end
+
+          controller.class_name.constantize.class_eval do
+            include Sbmt::Strangler::Mixin
+
+            controller.actions.each do |action|
+              define_method(action.name) do
+                @strangler_action = action
+
+                Sbmt::Strangler::ActionInvoker.new(
+                  rails_controller: self,
+                  strangler_action: action,
+                  metric_tracker: Sbmt::Strangler::MetricTracker.new(self),
+                  feature_flags: Sbmt::Strangler::FeatureFlags.new(
+                    rails_controller: self,
+                    strangler_action: action
+                  )
+                ).call
+              end
+            end
+          end
+        end
+      end
+
+      def add_feature_flags
+        configuration.controllers.each do |controller|
+          controller.actions.each do |action|
+            Sbmt::Strangler::FeatureFlags.new(strangler_action: action).add_all!
+          rescue => error
+            Sbmt::Strangler.logger.log_warn(
+              "Unable to add feature flags for action #{action.full_name}: #{error}",
+              error_class: error.class.name
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sbmt/strangler/configurable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Strangler
+    module Configurable
+      def option(*hash)
+        case hash
+        in [*attributes, Hash => options]
+        in [*attributes]
+          options = {}
+        end
+
+        attributes.each do |attribute|
+          define_method :"#{attribute}=" do |value|
+            instance_variable_set(:"@#{attribute}", value)
+          end
+
+          define_method attribute.to_s do
+            value = instance_variable_get(:"@#{attribute}")
+            return value if value
+
+            if options[:default_from]
+              value = send(options[:default_from])&.public_send(attribute)
+            end
+
+            value || options[:default]
+          end
+        end
+      end
+    end
+  end
+end