maybe_later 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 97eeed3e9c54c6fc50761b564b2931efb9095256dd204713202f661fd3bae530
+  data.tar.gz: c970f7ce158383f37d37e889b2e7eebc6709fb99a2c62fb70aab7f7ea8f6894f
+SHA512:
+  metadata.gz: d85dd59825388991863f20945f8ee5b1ee8f9ce133657c0910b0e5adffd61eee9eebb185d33f714f1cb33bf9c04bd70eb02be68ae059fba3ef31480244e3c183
+  data.tar.gz: ee4340c11eb2f7da34ea743947ca6f9649a3bf2e44923dd371990e7efc3c092e6dcc84943eb498080bad88f830f26a66c5b84de796f217c458056c1c88c1a9fa

data/.standard.yml

@@ -0,0 +1,2 @@
+# For available configuration options, see:
+#   https://github.com/testdouble/standard

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## [0.0.1] - 2022-01-19
+
+- Initial release

data/Gemfile

@@ -0,0 +1,11 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake"
+gem "minitest"
+gem "standard"
+
+gem "rack"
+
+gem "pry"

data/Gemfile.lock

@@ -0,0 +1,106 @@
+PATH
+  remote: .
+  specs:
+    maybe_later (0.0.1)
+      concurrent-ruby (~> 1.1.9)
+      railties (>= 6.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (7.0.1)
+      actionview (= 7.0.1)
+      activesupport (= 7.0.1)
+      rack (~> 2.0, >= 2.2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actionview (7.0.1)
+      activesupport (= 7.0.1)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activesupport (7.0.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    builder (3.2.4)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.9)
+    crass (1.0.6)
+    erubi (1.10.0)
+    i18n (1.8.11)
+      concurrent-ruby (~> 1.0)
+    loofah (2.13.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    method_source (1.0.0)
+    minitest (5.15.0)
+    nokogiri (1.13.1-arm64-darwin)
+      racc (~> 1.4)
+    parallel (1.21.0)
+    parser (3.1.0.0)
+      ast (~> 2.4.1)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    racc (1.6.0)
+    rack (2.2.3)
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.4.2)
+      loofah (~> 2.3)
+    railties (7.0.1)
+      actionpack (= 7.0.1)
+      activesupport (= 7.0.1)
+      method_source
+      rake (>= 12.2)
+      thor (~> 1.0)
+      zeitwerk (~> 2.5)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.2.0)
+    rexml (3.2.5)
+    rubocop (1.25.0)
+      parallel (~> 1.10)
+      parser (>= 3.1.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.15.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.15.1)
+      parser (>= 3.0.1.1)
+    rubocop-performance (1.13.2)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.11.0)
+    standard (1.7.0)
+      rubocop (= 1.25.0)
+      rubocop-performance (= 1.13.2)
+    thor (1.2.1)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.1.0)
+    zeitwerk (2.5.3)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  maybe_later!
+  minitest
+  pry
+  rack
+  rake
+  standard
+
+BUNDLED WITH
+   2.3.3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Justin Searls
+
+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,120 @@
+# maybe_later - get slow code out of your users' way
+
+Maybe you've been in this situation: you want to call some Ruby while responding
+to an HTTP request, but it's a time-consuming operation, its outcome won't
+impact the response you send, and naively invoking it will result in a slower
+page load or API response for your users.
+
+In almost all cases like this, Rubyists will reach for a [job
+queue](https://edgeguides.rubyonrails.org/active_job_basics.html). And that's
+usually the right answer! But for relatively trivial tasks—cases where the
+_only_ reason you want to defer execution is a faster page load—creating a new
+job class and scheduling the work onto a queuing system can feel like overkill.
+
+If this resonates with you, the `maybe_later` gem might be the best way to run
+that code for you (eventually).
+
+##  Bold Font Disclaimer
+
+⚠️ **If the name `maybe_later` didn't make it clear, this gem does nothing to
+ensure that your after-action callbacks actually run. If the code you're calling
+is very important, use [sidekiq](https://github.com/mperham/sidekiq) or
+something!** ⚠️
+
+## Setup
+
+Add the gem to your Gemfile:
+
+```ruby
+gem "maybe_later"
+```
+
+If you're using Rails, the gem's middleware will be registered automatically. If
+you're not using Rails but _are_ using a rack-based server that supports
+[env["rack.after_reply"]](https://github.com/rack/rack/issues/1060) (which
+includes
+[puma](https://github.com/puma/puma/commit/be4a8336c0b4fc911b99d1ffddc4733b6f38d81d)
+and
+[unicorn](https://github.com/defunkt/unicorn/commit/673c15e3f020bccc0336838617875b26c9a45f4e)),
+just add `use MaybeLater::Middleware` to your `config.ru` file.
+
+## Usage
+
+Using the gem is pretty straightforward, just pass the code you want to run to
+`MaybeLater.run` as a block:
+
+```ruby
+MaybeLater.run {
+  AnalyticsService.send_telemetry!
+}
+```
+
+Each block passed to `MaybeLater.run` will be run after the HTTP response is
+sent and the response will include a `"Connection: close` header.
+
+If the code you're calling needs to be executed in the same thread that's
+handling the HTTP request, you can pass `inline: true`:
+
+```ruby
+MaybeLater.run(inline: true) {
+  # Thread un-safe code here
+}
+```
+
+And your code will be run right after the HTTP response is sent (note: this can
+potentially saturate the server's available threads and effectively block
+subsequent HTTP requests!)
+
+
+## Configuration
+
+The gem offers a few configuration options:
+
+```ruby
+MaybeLater.config do |config|
+  # Will be called if a `MaybeLater.run {}` callback errors, e.g.:
+  config.on_error = ->(error) {
+    # e.g. Honeybadger.notify(error)
+  }
+
+  # Will run after each `MaybeLater.run {}` block, even if it errors
+  config.after_each = -> {}
+
+  # By default, tasks will run in a fixed thread pool. To run them in the
+  # thread dispatching the HTTP response, set this to true
+  config.inline_by_default = false
+
+  # How many threads to allocate to the fixed thread pool (default: 5)
+  config.max_threads = 5
+end
+```
+
+## Help! Why isn't my code running?
+
+If the blocks you pass to `MaybeLater.run` aren't running, possible
+explanations:
+
+* Because the blocks passed to `MaybeLater.run` are themselves stored in a
+  thread-local array, if you invoke `MaybeLater.run` from a thread that isn't
+  handling with a Rack request, the block will never run
+* If your Rack server doesn't support `rack.after_reply`, the blocks will never
+  run
+* If the block _is_ running and raising an error, you'll only know about it if
+  you register a `MaybeLater.config.on_error` handler
+
+## Acknowledgement
+
+The idea for this gem was triggered by [this
+tweet](https://twitter.com/julikt/status/1483585327277223939) in reply to [this
+question](https://twitter.com/searls/status/1483572597686259714). Also, many
+thanks to [Matthew Draper](https://github.com/matthewd) for answering a bunch of
+questions I had while implementing this.
+
+## Code of Conduct
+
+This project follows Test Double's [code of
+conduct](https://testdouble.com/code-of-conduct) for all community interactions,
+including (but not limited to) one-on-one communications, public posts/comments,
+code reviews, pull requests, and GitHub issues. If violations occur, Test Double
+will take any action they deem appropriate for the infraction, up to and
+including blocking a user from the organization's repositories.

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "standard/rake"
+
+task default: %i[test standard]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "maybe_later"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/maybe_later/config.rb

@@ -0,0 +1,12 @@
+module MaybeLater
+  class Config
+    attr_accessor :after_each, :on_error, :inline_by_default, :max_threads
+
+    def initialize
+      @after_each = nil
+      @on_error = nil
+      @inline_by_default = false
+      @max_threads = 5
+    end
+  end
+end

data/lib/maybe_later/middleware.rb

@@ -0,0 +1,21 @@
+module MaybeLater
+  class Middleware
+    RACK_AFTER_REPLY = "rack.after_reply"
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      if Store.instance.any_callbacks?
+        env[RACK_AFTER_REPLY] ||= []
+        env[RACK_AFTER_REPLY] << -> {
+          RunsCallbacks.new.call
+        }
+        headers["Connection"] = "close"
+      end
+      [status, headers, body]
+    end
+  end
+end

data/lib/maybe_later/queues_callback.rb

@@ -0,0 +1,15 @@
+module MaybeLater
+  Callback = Struct.new(:inline, :callable, keyword_init: true)
+
+  class QueuesCallback
+    def call(callable:, inline:)
+      raise Error.new("No block was passed to MaybeLater.run") if callable.nil?
+
+      inline = MaybeLater.config.inline_by_default if inline.nil?
+      Store.instance.add_callback(Callback.new(
+        inline: inline,
+        callable: callable
+      ))
+    end
+  end
+end

data/lib/maybe_later/railtie.rb

@@ -0,0 +1,7 @@
+module MaybeLater
+  class Railtie < ::Rails::Railtie
+    initializer "maybe_later.middleware" do
+      config.app_middleware.use Middleware
+    end
+  end
+end

data/lib/maybe_later/runs_callbacks.rb

@@ -0,0 +1,22 @@
+module MaybeLater
+  class RunsCallbacks
+    def call
+      store = Store.instance
+      config = MaybeLater.config
+
+      store.callbacks.each do |callback|
+        if callback.inline
+          callback.callable.call
+        else
+          ThreadPool.instance.run(callback.callable)
+        end
+      rescue => e
+        config.on_error&.call(e)
+      ensure
+        config.after_each&.call
+      end
+
+      store.clear_callbacks!
+    end
+  end
+end

data/lib/maybe_later/store.rb

@@ -0,0 +1,24 @@
+module MaybeLater
+  class Store
+    def self.instance
+      Thread.current[:maybe_later_store] ||= new
+    end
+
+    attr_reader :callbacks
+    def initialize
+      @callbacks = []
+    end
+
+    def any_callbacks?
+      !@callbacks.empty?
+    end
+
+    def add_callback(callable)
+      @callbacks << callable
+    end
+
+    def clear_callbacks!
+      @callbacks = []
+    end
+  end
+end

data/lib/maybe_later/thread_pool.rb

@@ -0,0 +1,22 @@
+module MaybeLater
+  class ThreadPool
+    def self.instance
+      @instance ||= new
+    end
+
+    # The only time this is invoked by the gem will be when an Async task runs
+    # As a result, the max thread config will be locked after responding to the
+    # first relevant request, since the pool will have been created
+    def initialize
+      @pool = Concurrent::FixedThreadPool.new(MaybeLater.config.max_threads)
+    end
+
+    def run(callable)
+      @pool.post do
+        callable.call
+      rescue => e
+        MaybeLater.config.on_error&.call(e)
+      end
+    end
+  end
+end

data/lib/maybe_later/version.rb

@@ -0,0 +1,3 @@
+module MaybeLater
+  VERSION = "0.0.1"
+end

data/lib/maybe_later.rb

@@ -0,0 +1,22 @@
+require_relative "maybe_later/version"
+require_relative "maybe_later/config"
+require_relative "maybe_later/middleware"
+require_relative "maybe_later/queues_callback"
+require_relative "maybe_later/runs_callbacks"
+require_relative "maybe_later/store"
+require_relative "maybe_later/thread_pool"
+require_relative "maybe_later/railtie" if defined?(Rails)
+
+module MaybeLater
+  class Error < StandardError; end
+
+  def self.run(inline: nil, &blk)
+    QueuesCallback.new.call(callable: blk, inline: inline)
+  end
+
+  def self.config(&blk)
+    (@config ||= Config.new).tap { |config|
+      blk&.call(config)
+    }
+  end
+end

data/maybe_later.gemspec

@@ -0,0 +1,32 @@
+require_relative "lib/maybe_later/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "maybe_later"
+  spec.version = MaybeLater::VERSION
+  spec.authors = ["Justin Searls"]
+  spec.email = ["searls@gmail.com"]
+
+  spec.summary = "Run code after the current Rack response or Rails action completes"
+  spec.homepage = "https://github.com/testdouble/maybe_later"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "railties", ">= 6.0.0"
+  spec.add_dependency "concurrent-ruby", "~> 1.1.9"
+end

data/sig/maybe_later.rbs

@@ -0,0 +1,4 @@
+module MaybeLater
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: maybe_later
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Justin Searls
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-01-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+description:
+email:
+- searls@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/maybe_later.rb
+- lib/maybe_later/config.rb
+- lib/maybe_later/middleware.rb
+- lib/maybe_later/queues_callback.rb
+- lib/maybe_later/railtie.rb
+- lib/maybe_later/runs_callbacks.rb
+- lib/maybe_later/store.rb
+- lib/maybe_later/thread_pool.rb
+- lib/maybe_later/version.rb
+- maybe_later.gemspec
+- sig/maybe_later.rbs
+homepage: https://github.com/testdouble/maybe_later
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/testdouble/maybe_later
+  source_code_uri: https://github.com/testdouble/maybe_later
+  changelog_uri: https://github.com/testdouble/maybe_later/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: Run code after the current Rack response or Rails action completes
+test_files: []