fly-ruby 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82d6cde56b619737984124f61e7fc526129eebb493e1954f9b9b171202d8eed0
-  data.tar.gz: 2a14fee50d07739be04a19476128671878fb448fbe1cf23654df254beba4507a
+  metadata.gz: 506556ce79da83a817f5a6a56b336328912730ace3fb26d10ed0d7e97f971abc
+  data.tar.gz: c2c7ceb044a6a9054da36ae775a0693458e91dac271b5d341666995dd59373b5
 SHA512:
-  metadata.gz: 87c976601cddc300a435f503983f5de87e54c7965b07fd36232526c8e3da26e4ac2f40b729e6f701924d9371872adeaafd780937eb9a750af95c8f6cb59b9012
-  data.tar.gz: 0c528dbb8a6d4035a754f8b580562c21194a37e999c64f82831aa2c70e0cb53b3687d9e94bbcaf67fe7ca1526f96232b87bb77a4dac1d017b30dcca080c9315d
+  metadata.gz: d7a79ba9b2a2db74515bdce0c606c99072d292813b5ef34c8963d44bcc0366fe0230bc784dcb8e489614ef1dd33ebb447d7cb215fd7f475c0fc00d51487446cf
+  data.tar.gz: 38e26c8853bde15845b1cd1c34bcff68f5f87db5a8e726af4451329619b54f3c4dfa26ffd83832e24ea0a743401b1e28c011316ab78b08c60cc76e42022bec58

data/.github/workflows/test.yml

@@ -7,12 +7,35 @@ jobs:
     strategy:
       matrix:
         include:
-          - { os: ubuntu-latest, ruby_version: 2.4 }
           - { os: ubuntu-latest, ruby_version: 2.5 }
           - { os: ubuntu-latest, ruby_version: 2.6 }
           - { os: ubuntu-latest, ruby_version: 2.7 }
           - { os: ubuntu-latest, ruby_version: '3.0' }
-          - { os: ubuntu-latest, ruby_version: jruby }
+    services:
+    # label used to access the service container
+      postgres:
+        # Docker Hub image
+        image: postgres:latest
+        # service environment variables
+        # `POSTGRES_HOST` is `postgres`
+        env:
+          # optional (defaults to `postgres`)
+          POSTGRES_DB: fly_ruby_test
+          # required
+          POSTGRES_PASSWORD: postgres_password
+          # optional (defaults to `5432`)
+          POSTGRES_PORT: 5432
+          # optional (defaults to `postgres`)
+          POSTGRES_USER: postgres_user
+        ports:
+          # maps tcp port 5432 on service container to the host
+          - 5432:5432
+        # set health checks to wait until postgres has started
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
     steps:
     - name: Setup Ruby, JRuby and TruffleRuby
       uses: ruby/setup-ruby@v1.75.0
@@ -22,6 +45,8 @@ jobs:
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Run tests
+      env:
+        DATABASE_USER: postgres_user
       run: |
         bundle install --jobs 4 --retry 3
         rake

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+## 0.2.1
+
+### 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
+
+### Features
+
+- Add `Fly-Region` and `Fly-Database-Host` response headers for easier debugging

data/Gemfile

@@ -1,5 +1,11 @@
 source 'https://rubygems.org'
 
+gemspec
+
 gem 'rack-test'
 gem 'minitest'
-gemspec
+gem "rails"
+gem "pg"
+gem "climate_control"
+gem "minitest-around"
+gem "m"

data/README.md

@@ -1,23 +1,25 @@
 [![Test](https://github.com/superfly/fly-ruby/actions/workflows/test.yml/badge.svg)](https://github.com/superfly/fly-ruby/actions/workflows/test.yml)
 
-# Augment Ruby web apps on Fly.io
+This gem contains helper code and Rack middleware for deploying Ruby web apps on [Fly.io](https://fly.io). Supported features:
 
-[Fly.io](https://fly.io) offers a number of native features that can improve the perceived speed and observability of web applications with minimal configuration. This gem automates some of the work required to take advantage of these features.
+* Speed up apps by using region-local Postgresql replicas for database reads
 
-## Regional replicas 
+## Speed up apps using region-local database replicas
 
-Running database replicas alongside your apps in multiple regions [is quick and easy with Fly's Postgresql cluster](https://fly.io/docs/getting-started/multi-region-databases/). This can increase the perceived speed of read-heavy applications.
+Fly's [cross-region private networking](https://fly.io/docs/reference/privatenetwork/) makes it easy to run database replicas [alongside your app instances in multiple regions](https://fly.io/docs/getting-started/multi-region-databases/). These replicas can be used for faster reads and application performance.
 
-The catch: in most primary/replica setups, you have one writeable primary located in a specific region. Fly solves this by allowing requests to be *replyed*, at the routing layer, in another region.
+Writes, however, will be slow if performed across regions. Fly allows web apps to specify that a request be *replayed*, at the routing layer, in another region.
 
-This repository includes the `fly-ruby` gem which will utomatcally route requests that write to the database to the primary region. It should work
-with any Rack-compatible Ruby framework.
+This gem includes Rack middleware to automatically route such requests to the primary region. It's designed should work with any Rack-compatible Ruby framework.
 
 Currently, it does this by:
 
 * modifying the `DATABASE_URL` to point apps to their local regional replica
 * replaying non-idempotent (post/put/patch/delete) requests in the primary region
-* catching Postgresql exceptions caused by writes to a read-only replica, and replaying these requests in the primary region
+* catching Postgresql exceptions caused by writes to a read-only replica, and asking for
+  these requests to be replayed in the primary region
+* replaying all requests within a time threshold after a write, to avoid users seeing
+  their own stale data due to replication lag
 
 ## Requirements
 
@@ -35,7 +37,7 @@ Add to your Gemfile and `bundle install`:
 
 `gem "fly-ruby"`
 
-If you're on Rails, the middleware will insert itself automatically at the top of the Rack middleware stack.
+If you're on Rails, the middleware will insert itself automatically, and attempt to reconnect the database.
 
 ## Configuration
 
@@ -52,7 +54,7 @@ See [the source code](https://github.com/soupedup/fly-rails/blob/main/lib/fly-ra
 
 This middleware send all requests to the primary if you do something like update a user's database session on every GET request.
 
-If your replica becomes writeable for some reason, your custer may get out of sync.
+If your replica becomes writeable for some reason, your cluster may get out of sync.
 
 ## TODO
 

data/Rakefile

@@ -1,5 +1,6 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
+require_relative "lib/fly-ruby/version"
 
 Rake::TestTask.new do |t|
   t.libs << "test"
@@ -10,7 +11,15 @@ end
 desc "Run tests"
 task default: :test
 
-
 task :top do
   puts Rake.application.top_level_tasks
 end
+
+task :publish do
+  version = Fly::VERSION
+  puts "Publishing fly-ruby #{version}..."
+  sh "git tag -f v#{version}"
+  sh "gem build"
+  sh "gem push fly-ruby-#{version}.gem"
+  sh "git push --tags"
+end

data/lib/fly-ruby/configuration.rb

@@ -15,6 +15,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.
@@ -24,23 +25,82 @@ module Fly
     # primary region after a successful write replay
     attr_accessor :replay_threshold_in_seconds
 
+    attr_accessor :database_url
+    attr_accessor :redis_url
+
     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]
+    end
+
+    def database_uri
+      @database_uri ||= URI.parse(database_url)
+      @database_uri
+    end
+
+    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" => regional_database_host,
+        "port" => 5433,
+        "adapter" => "postgresql"
+      }
+    end
+
+    def redis_uri
+      @redis_uri ||= URI.parse(redis_url)
+      @redis_uri
     end
 
-    def database_url
-      ENV[database_url_env_var]
+    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
+      database_url && primary_region && current_region && web?
+    end
+
+    def in_secondary_region?
+      primary_region && primary_region != current_region
+    end
+
+    # Is the current process a Rails console?
+    def console?
+      defined?(::Rails::Console) && $stdout.isatty && $stdin.isatty
+    end
+
+    # Is the current process a rake task?
+    def rake_task?
+      defined?(::Rake) && !Rake.application.top_level_tasks.empty?
+    end
+
+    def web?
+      !console? && !rake_task?
     end
   end
 end

data/lib/fly-ruby/railtie.rb

@@ -1,8 +1,38 @@
 class Fly::Railtie < Rails::Railtie
+  def hijack_database_connection
+    ActiveSupport::Reloader.to_prepare do
+      # If we already have a database connection when this initializer runs,
+      # we should reconnect to the region-local database. This may need some additional
+      # 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))
+      end
+    end
+  end
+
+  # Set useful headers for debugging
+  def set_debug_response_headers
+    ActiveSupport::Reloader.to_prepare do
+      ApplicationController.send(:after_action) do
+        response.headers['Fly-Region'] = ENV['FLY_REGION']
+      end
+    end
+  end
+
   initializer("fly.regional_database") do |app|
+    set_debug_response_headers if Fly.configuration.web?
+
     if Fly.configuration.eligible_for_activation?
-      app.config.middleware.insert_after ActionDispatch::Executor, Fly::RegionalDatabase
-    elsif !ENV["TESTING"]
+      # Insert the request interceptor high in the stack, but after static file delivery
+      app.config.middleware.insert_after ActionDispatch::Executor, 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
+
+      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
   end

data/lib/fly-ruby/regional_database.rb

@@ -5,49 +5,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
-      prefer_regional_database! unless in_primary_region?
-    end
-
-    def console?
-      defined?(::Rails::Console) && $stdout.isatty && $stdin.isatty
-    end
-
-    def rake_task?
-      defined?(::Rake) && !Rake.application.top_level_tasks.empty?
-    end
-
-    # Overwrite the primary database URL with that of the regional replica
-    def prefer_regional_database!
-      # Don't override the database if migrations are running
-      return if console? || rake_task?
-
-      uri = URI.parse(Fly.configuration.database_url)
-      hostname = "#{Fly.configuration.current_region}.#{uri.hostname}"
-      port = 5433
-
-      uri.hostname = hostname
-      uri.port = port
-      uri.to_s
-
-      ENV[Fly.configuration.database_url_env_var] = uri.to_s
-      ENV[Fly.configuration.database_host_env_var] = hostname
-      ENV[Fly.configuration.database_port_env_var] = 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:
     #
@@ -55,70 +13,83 @@ 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)
+        @app.call(env)
+      rescue PG::ReadOnlySqlTransaction, ActiveRecord::StatementInvalid => e
+        if e.is_a?(PG::ReadOnlySqlTransaction) || e&.cause&.is_a?(PG::ReadOnlySqlTransaction)
+          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&.scan(/(.*?)=(.*?)($|;)/)&.detect { |v| v[0] == "state" }&.at(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 = Rack::Response.new(body, status, headers)
+        replay_state = replay_request_state(request.get_header("HTTP_FLY_REPLAY_SRC"))
 
-      response.finish
+        # 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,3 @@
-class Fly
-  VERSION = "0.1.1"
+module Fly
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fly-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Joshua Sierles
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-08 00:00:00.000000000 Z
+date: 2021-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -33,6 +33,7 @@ extra_rdoc_files: []
 files:
 - ".github/workflows/test.yml"
 - ".gitignore"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md