fly-ruby 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79850f3de9e2a7e78ff9d46ba7728c605fae5651786d3a425dec0d12056d75b6
-  data.tar.gz: 5349dfbb16a8a257a909c68410f2041bf5202bbeed5ae88e496a9efa2e1c9478
+  metadata.gz: ea1ca64bcd11ed8a60774f0d8ec255ffb49bc6b8e21a8bd32e7410068bec35c0
+  data.tar.gz: fb55ad6c98cb631bf202aea206c53a9b2e9a7c738cd9835095dd647011cfc7f6
 SHA512:
-  metadata.gz: e43ad67e8d81f5d817ad274bb0f2e2a97d276fc1a9f0bb78549ea6cc06b5c2e5a90fd2ddd03f7529f592cf037bed68ed9f172945425829b7952acbdd4c20df58
-  data.tar.gz: d91c4fd6e1a5d3619165c9a44076840ac331c8533f0cb94f34001022d987bca1f7b654de34668cc6029305341f39bc7caa22b31ad76968802261fd884816b878
+  metadata.gz: 7c3df04f8bb9f97bfb87903b0fffc14ef2b320802e1183752c07f8b769b629f6c66af21ae0e4bb5a23a2608cfdfdda2f3b1c387e3edcd1f64b5d2474a79f7a6f
+  data.tar.gz: ff4ca7c18d4b18ec237c8e1c59bce88dce849198934ed1d42c28ab2a081b577f8fa2cc38930d0478ec94a5bee580e2f12649b38d3ad46d176a774edaba60446c

data/.gitignore

@@ -4,3 +4,4 @@ log/
 Gemfile.lock
 .ruby-version
 *.gem
+db/

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ### Bug fixes
 
+- Run the database exception handler at the bottom of the stack to ensure it will take priority over other exception handlers
+
+## 0.2.1
+
+### Bug fixes
+
 - Only hijack the database connection for requests in secondary regions
 
 ## 0.2.0

data/README.md

@@ -1,8 +1,8 @@
 [![Test](https://github.com/superfly/fly-ruby/actions/workflows/test.yml/badge.svg)](https://github.com/superfly/fly-ruby/actions/workflows/test.yml)
 
-This gem contains helper code and Rack middleware for deploying Ruby web apps on [Fly.io](https://fly.io). Supported features:
+This gem contains helper code and Rack middleware for deploying Ruby web apps on [Fly.io](https://fly.io). It's designed to speed up apps by using region-local Postgresql replicas for database reads. See the blog post for more details:
 
-* Speed up apps by using region-local Postgresql replicas for database reads
+https://fly.io/blog/run-ordinary-rails-apps-globally
 
 ## Speed up apps using region-local database replicas
 
@@ -49,7 +49,7 @@ Fly.configure do |c|
 end
 ```
 
-See [the source code](https://github.com/soupedup/fly-rails/blob/main/lib/fly-rails/configuration.rb) for defaults and available configuration options.
+See [the source code](https://github.com/superfly/fly-ruby/blob/main/lib/fly-ruby/configuration.rb) for defaults and available configuration options.
 ## Known issues
 
 This middleware send all requests to the primary if you do something like update a user's database session on every GET request.

data/lib/fly-ruby/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fly
   class Configuration
     # Set the region where this instance of the application is deployed
@@ -15,6 +17,7 @@ module Fly
     attr_accessor :database_url_env_var
     attr_accessor :database_host_env_var
     attr_accessor :database_port_env_var
+    attr_accessor :redis_url_env_var
 
     # Cookie written and read by this middleware storing a UNIX timestamp.
     # Requests arriving before this timestamp will be replayed in the primary region.
@@ -25,33 +28,77 @@ module Fly
     attr_accessor :replay_threshold_in_seconds
 
     attr_accessor :database_url
+    attr_accessor :redis_url
+
+    # An array of string representations of exceptions that should trigger a replay
+    attr_accessor :replayable_exceptions
 
     def initialize
       self.primary_region = ENV["PRIMARY_REGION"]
       self.current_region = ENV["FLY_REGION"]
       self.replay_http_methods = ["POST", "PUT", "PATCH", "DELETE"]
       self.database_url_env_var = "DATABASE_URL"
+      self.redis_url_env_var = "REDIS_URL"
       self.database_host_env_var = "DATABASE_HOST"
       self.database_port_env_var = "DATABASE_PORT"
       self.replay_threshold_cookie = "fly-replay-threshold"
       self.replay_threshold_in_seconds = 5
       self.database_url = ENV[database_url_env_var]
+      self.redis_url = ENV[redis_url_env_var]
+      self.replayable_exceptions = ["SQLite3::CantOpenException", "PG::ReadOnlySqlTransaction"]
+    end
+
+    def replayable_exception_classes
+      @replayable_exception_classes ||= replayable_exceptions.collect {|ex| module_exists?(ex) }.compact
+      @replayable_exception_classes
+    end
+
+    def module_exists?(module_name)
+      mod = Module.const_get(module_name)
+      return mod
+    rescue NameError
+      nil
+    end
+
+    def database_uri
+      @database_uri ||= URI.parse(database_url)
+      @database_uri
     end
 
-    def regional_database_uri
-      @uri ||= URI.parse(database_url)
-      @uri
+    def regional_database_url
+      uri = database_uri.dup
+      uri.host = regional_database_host
+      uri.to_s
+    end
+
+    def regional_database_host
+      "#{current_region}.#{database_uri.hostname}"
     end
 
     # Rails-compatible database configuration
     def regional_database_config
       {
-        "host" => "#{current_region}.#{regional_database_uri.hostname}",
-        "port" => 5433,
-        "adapter" => "postgresql"
+        :host => regional_database_host,
+        :port => 5433,
+        :adapter => "postgresql"
       }
     end
 
+    def redis_uri
+      @redis_uri ||= URI.parse(redis_url)
+      @redis_uri
+    end
+
+    def regional_redis_host
+      "#{current_region}.#{redis_uri.hostname}"
+    end
+
+    def regional_redis_url
+      uri = redis_uri.dup
+      uri.host = regional_redis_host
+      uri.to_s
+    end
+
     def eligible_for_activation?
       database_url && primary_region && current_region && web?
     end

data/lib/fly-ruby/headers.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Fly
+  class Headers
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      response = Rack::Response.new(body, status, headers)
+      response.set_header('Fly-Region', ENV['FLY_REGION'])
+      response.finish
+    end
+  end
+end

data/lib/fly-ruby/railtie.rb

@@ -1,4 +1,4 @@
-require_relative '../fly-ruby'
+# frozen_string_literal: true
 
 class Fly::Railtie < Rails::Railtie
   def hijack_database_connection
@@ -8,28 +8,23 @@ class Fly::Railtie < Rails::Railtie
       # hooks for forking servers to work correctly.
       if defined?(ActiveRecord)
         config = ActiveRecord::Base.connection_db_config.configuration_hash
-        ActiveRecord::Base.establish_connection(config.merge(Fly.configuration.regional_database_config))
+        ActiveRecord::Base.establish_connection(config.symbolize_keys.merge(Fly.configuration.regional_database_config))
       end
     end
   end
 
-  # Set useful headers for debugging
-  def set_debug_response_headers
-    return unless defined?(ApplicationController)
-
-    ApplicationController.send(:after_action) do
-      response.headers['Fly-Region'] = ENV['FLY_REGION']
-      response.headers['Fly-Database-Host'] = Fly.configuration.regional_database_config["host"]
-    end
-  end
-
   initializer("fly.regional_database") do |app|
-    set_debug_response_headers
+    # Insert the request middleware high in the stack, but after static file delivery
+    app.config.middleware.insert_after ActionDispatch::Executor, Fly::Headers if Fly.configuration.web?
+
     if Fly.configuration.eligible_for_activation?
-      app.config.middleware.insert_after ActionDispatch::Executor, Fly::RegionalDatabase
+      app.config.middleware.insert_after Fly::Headers, Fly::RegionalDatabase::ReplayableRequestMiddleware
+      # Insert the database exception handler at the bottom of the stack to take priority over other exception handlers
+      app.config.middleware.use Fly::RegionalDatabase::DbExceptionHandlerMiddleware
 
-      # Run the middleware high in the stack, but after static file delivery
-      hijack_database_connection if Fly.configuration.in_secondary_region?
+      if Fly.configuration.in_secondary_region?
+        hijack_database_connection
+      end
     elsif Fly.configuration.web?
       puts "Warning: DATABASE_URL, PRIMARY_REGION and FLY_REGION must be set to activate the fly-ruby middleware. Middleware not loaded."
     end

data/lib/fly-ruby/regional_database.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rake'
 
 module Fly
@@ -5,39 +7,7 @@ module Fly
   # multithreaded environments. Instead of using dirty tricks like using Object#dup,
   # values are passed to methods.
 
-  class RegionalDatabase
-    def initialize(app)
-      @app = app
-    end
-
-    # Overwrite the database connection string environment variable
-    # to prefer connections to the regional replica.
-    #
-    # For Rails apps, this process will be repeated at middleware insertion time,
-    # to support situations where the database is already accessed by other
-    # initialization code. See Fly::Railtie.
-
-    def prefer_regional_database!
-      return if Fly.configuration.web?
-
-      uri = Fly.configuration.database_uri
-
-      ENV[Fly.configuration.database_url_env_var] = uri.to_s
-      ENV[Fly.configuration.database_host_env_var] = uri.hostname
-      ENV[Fly.configuration.database_port_env_var] = uri.port.to_s
-    end
-
-    def in_primary_region?
-      Fly.configuration.primary_region == Fly.configuration.current_region
-    end
-
-    def regional_database_url
-    end
-
-    def response_body
-      "<html>Replaying request in #{Fly.configuration.primary_region}</html>"
-    end
-
+  module RegionalDatabase
     # Stop the current request and ask for it to be replayed in the primary region.
     # Pass one of three states to the target region, to determine how to handle the request:
     #
@@ -45,70 +15,84 @@ module Fly
     # captured_write: A write was rejected by the database
     # http_method: A non-idempotent HTTP method was replayed before hitting the application
     # threshold: A recent write set a threshold during which all requests are replayed
-    #
-    def replay_in_primary_region!(state:)
+
+    def self.replay_in_primary_region!(state:)
       res = Rack::Response.new(
-        response_body,
+        "",
         409,
-        {"fly-replay" => "region=#{Fly.configuration.primary_region};state=#{state}"}
+        {"Fly-Replay" => "region=#{Fly.configuration.primary_region};state=#{state}"}
       )
       res.finish
     end
 
-    def within_replay_threshold?(threshold)
-      threshold && (threshold.to_i - Time.now.to_i) > 0
-    end
+    class DbExceptionHandlerMiddleware
+      def initialize(app)
+        @app = app
+      end
 
-    def replayable_http_method?(http_method)
-      Fly.configuration.replay_http_methods.include?(http_method)
+      def call(env)
+        exceptions = Fly.configuration.replayable_exception_classes
+        @app.call(env)
+      rescue *exceptions, ActiveRecord::RecordInvalid => e
+        if exceptions.any? {|ex| e.is_a?(ex) } || exceptions.any? { e&.cause&.is_a?(e) }
+          RegionalDatabase.replay_in_primary_region!(state: "captured_write")
+        else
+          raise e
+        end
+      end
     end
 
-    def replay_request_state(header_value)
-      header_value&.scan(/(.*?)=(.*?)($|;)/)&.detect { |v| v[0] == "state" }&.at(1)
-    end
+    class ReplayableRequestMiddleware
+      def initialize(app)
+        @app = app
+      end
 
-    def call(env)
-      request = Rack::Request.new(env)
+      def within_replay_threshold?(threshold)
+        threshold && (threshold.to_i - Time.now.to_i) > 0
+      end
 
-    # Check whether this request satisfies any of the following conditions for replaying in the primary region:
-    #
-    # 1. Its HTTP method matches those configured for automatic replay (post/patch/put/delete by default).
-    #    This approach should avoid potentially slow code execution - before_actions or other controller code -
-    #    happening before a request reaches a database write.
-    # 2. It arrived before the threshold defined by the last write request. This threshold
-    #    helps avoid the same client from missing its own write due to replication lag,
-    #    like when a user adds to a todo list via XHR
-
-      if !in_primary_region?
-        if replayable_http_method?(request.request_method)
-          return replay_in_primary_region!(state: "http_method")
-        elsif within_replay_threshold?(request.cookies[Fly.configuration.replay_threshold_cookie])
-          return replay_in_primary_region!(state: "threshold")
-        end
+      def replayable_http_method?(http_method)
+        Fly.configuration.replay_http_methods.include?(http_method)
       end
 
-      begin
-        status, headers, body = @app.call(env)
-      rescue ActiveRecord::StatementInvalid => e
-        if e.cause.is_a?(PG::ReadOnlySqlTransaction)
-          return replay_in_primary_region!(state: "captured_write")
-        else
-          raise e
-        end
+      def replay_request_state(header_value)
+        header_value&.slice(/(?:^|;)state=([^;]*)/, 1)
       end
 
-      response = Rack::Response.new(body, status, headers)
-      replay_state = replay_request_state(request.get_header("HTTP_FLY_REPLAY_SRC"))
+      def call(env)
+        request = Rack::Request.new(env)
+
+        # Does this request satisfiy a condition for replaying in the primary region?
+        #
+        # 1. Its HTTP method matches those configured for automatic replay
+        # 2. It arrived before the threshold defined by the last write request.
+        #    This threshold helps avoid the same client from missing its own
+        #    write due to replication lag.
+
+        if Fly.configuration.in_secondary_region?
+          if replayable_http_method?(request.request_method)
+            return RegionalDatabase.replay_in_primary_region!(state: "http_method")
+          elsif within_replay_threshold?(request.cookies[Fly.configuration.replay_threshold_cookie])
+            return RegionalDatabase.replay_in_primary_region!(state: "threshold")
+          end
+        end
 
-      # Request was replayed, but not by a threshold
-      if replay_state && replay_state != "threshold"
-        response.set_cookie(
-          Fly.configuration.replay_threshold_cookie,
-          Time.now.to_i + Fly.configuration.replay_threshold_in_seconds
-        )
-      end
+        status, headers, body = @app.call(env)
 
-      response.finish
+        response = Rack::Response.new(body, status, headers)
+        replay_state = replay_request_state(request.get_header("HTTP_FLY_REPLAY_SRC"))
+
+        # Request was replayed, but not by a threshold, so set a threshold within which
+        # all requests should be replayed to the primary region
+        if replay_state && replay_state != "threshold"
+          response.set_cookie(
+            Fly.configuration.replay_threshold_cookie,
+            Time.now.to_i + Fly.configuration.replay_threshold_in_seconds
+          )
+        end
+
+        response.finish
+      end
     end
   end
 end

data/lib/fly-ruby/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fly
-  VERSION = "0.2.1"
+  VERSION = "0.4.0"
 end

data/lib/fly-ruby.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 require_relative "fly-ruby/configuration"
 require_relative "fly-ruby/regional_database"
+require_relative "fly-ruby/headers"
+
 require "forwardable"
 
 if defined?(::Rails)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fly-ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Joshua Sierles
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-15 00:00:00.000000000 Z
+date: 2022-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -41,6 +41,7 @@ files:
 - fly-ruby.gemspec
 - lib/fly-ruby.rb
 - lib/fly-ruby/configuration.rb
+- lib/fly-ruby/headers.rb
 - lib/fly-ruby/railtie.rb
 - lib/fly-ruby/regional_database.rb
 - lib/fly-ruby/version.rb
@@ -63,7 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.26
 signing_key:
 specification_version: 4
 summary: Augment Ruby web apps for deployment in Fly.io