cutoff 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e27bb02cc23dc725a4bcd3b9585159723e3fa4d3c88f98ec207ff2b91cf438d4
+  data.tar.gz: 8ab5a3a462bbbb2a32837e69de70d55ac59b3e347ead1db889d374f2be5b9224
+SHA512:
+  metadata.gz: c957634f0bc03f9fa8fb058080338978322adb54fce2c2c952c7b684ea3a979165f076abdc29878e416a084acd7b904ad6e8d637f0c1b90091ffa179fdb6076d
+  data.tar.gz: b9ac92d37812b341fba24c6a3feb5c0f1f4c9265f1995aa5266b85e3d46e27c48e80fd4801ecc4f46d9a22b5195e0b1dfc35bc9c74449e2ac35c11ace28a5f15

data/.yardopts

@@ -0,0 +1,3 @@
+--markup markdown
+--markup-provider redcarpet
+--no-private

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2021-07-19
+
+### Added
+
+- Cutoff class
+- Mysql2 patch
+
+[0.1.0]: https://github.com/justinhoward/cutoff/releases/tag/v0.1.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Justin Howard
+
+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,373 @@
+Cutoff
+==================
+
+[![Gem Version](https://badge.fury.io/rb/cutoff.svg)](https://badge.fury.io/rb/cutoff)
+[![CI](https://github.com/justinhoward/cutoff/workflows/CI/badge.svg)](https://github.com/justinhoward/cutoff/actions?query=workflow%3ACI+branch%3Amaster)
+[![Code Quality](https://app.codacy.com/project/badge/Grade/2748da79ec294f909996a56f11caac4a)](https://www.codacy.com/gh/justinhoward/cutoff/dashboard?utm_source=github.com&utm_medium=referral&utm_content=justinhoward/cutoff&utm_campaign=Badge_Grade)
+[![Code Coverage](https://app.codacy.com/project/badge/Coverage/2748da79ec294f909996a56f11caac4a)](https://www.codacy.com/gh/justinhoward/cutoff/dashboard?utm_source=github.com&utm_medium=referral&utm_content=justinhoward/cutoff&utm_campaign=Badge_Coverage)
+[![Inline docs](http://inch-ci.org/github/justinhoward/cutoff.svg?branch=master)](http://inch-ci.org/github/justinhoward/cutoff)
+
+A deadlines library for Ruby inspired by Shopify and
+[Kir Shatrov's blog series][kir shatrov].
+
+
+```ruby
+Cutoff.wrap(5) do
+  sleep(4)
+  Cutoff.checkpoint! # still have time left
+  sleep(2)
+  Cutoff.checkpoint! # raises an error
+end
+```
+
+It has a built-in patch for Mysql2 to auto-insert checkpoints and timeout query
+hints.
+
+```ruby
+require 'cutoff/patch/mysql2'
+
+client = Mysql2::Client.new
+Cutoff.wrap(5) do
+  client.query('SELECT * FROM dual WHERE sleep(2)')
+
+  # Cutoff will automatically insert a /*+ MAX_EXECUTION_TIME(3000) */
+  # hint so that MySQL will terminate the query after the time remaining
+  #
+  # Or if time already expired, this will raise an error and not be executed
+  client.query('SELECT * FROM dual WHERE sleep(1)')
+end
+```
+
+Why use deadlines?
+------------------------
+
+If you've already implemented timeouts for your networked dependencies, then you
+can be sure that no single HTTP request or database query can take longer than
+the time allotted to it.
+
+For example, let's say you set a query timeout of 3 seconds. That means no
+single query will take longer than 3 seconds. However, imagine a bad controller
+action or background job executes 100 slow queries. In that case, the queries
+add up to 300 seconds, much too long.
+
+Deadlines keep track of the total elapsed time in a request of job and interrupt
+it if it takes too long.
+
+Installation
+---------------
+
+Add it to your `Gemfile`:
+
+```ruby
+gem 'cutoff'
+```
+
+Or install it manually:
+
+```sh
+gem install cutoff
+```
+
+API Documentation
+------------------
+
+API docs can be read [on rubydoc.info][api docs], inline in the source code, or
+you can generate them yourself with Ruby `yard`:
+
+```sh
+bin/yardoc
+```
+
+Then open `doc/index.html` in your browser.
+
+Usage
+-----------
+
+The simplest way to use Cutoff is to use its class methods, although it can be
+used in an object-oriented manner as well.
+
+### Wrapping a block
+
+```ruby
+Cutoff.wrap(3.5) do # number of allowed seconds for this block
+  # Do something time-consuming here
+
+  # At a good stopping point, call checkpoint!
+  # If the allowed time is exceeded, this raises a Cutoff::CutoffExceededError
+  # otherwise, it does nothing
+  Cutoff.checkpoint!
+
+  # Now continue executing
+end
+```
+
+### Creating your own instance
+
+```ruby
+cutoff = Cutoff.new(6.4)
+sleep(10)
+cutoff.checkpoint! # Raises Cutoff::CutoffExceededError
+```
+
+### Getting cutoff details
+
+Cutoff has some instance methods to get information about the time remaining,
+etc.
+
+```ruby
+# If you're using Cutoff class methods, you can get the current instance
+cutoff = Cutoff.current # careful, this will be nil if a cutoff isn't running
+```
+
+Once you have an instance, either by creating your own or from `.current`, you
+have access to these methods.
+
+```ruby
+cutoff = Cutoff.current
+
+# These return Floats
+cutoff.allowed_seconds # Total seconds allowed (the seconds given when cutoff was started)
+cutoff.seconds_remaining # Seconds left
+cutoff.elapsed_seconds # Seconds since the cutoff was started
+cutoff.ms_remaining # Milliseconds left
+
+cutoff.exceeded? # True if the cutoff is expired
+```
+
+Patches
+-------------
+
+Cutoff is in early stages, but it aims to provide patches for common networked
+dependencies. The first of these is the `mysql2` patch. It is not loaded by
+default, so you need to require it manually.
+
+```ruby
+# In your Gemfile
+gem 'cutoff', require: %w[cutoff cutoff/patch/mysql2]
+```
+
+```ruby
+# Or manually
+require 'cutoff'
+require 'cutoff/patch/mysql2'
+```
+
+Once it is enabled, any `Mysql2::Client` object will respect the current cutoff
+if one is set.
+
+```ruby
+client = Mysql2::Client.new
+Cutoff.wrap(3) do
+  sleep(4)
+
+  # This query will not be executed because the time is already expired
+  client.query('SELECT * FROM users')
+end
+
+Cutoff.wrap(3) do
+  sleep(1)
+
+  # There are 2 seconds left, so a MAX_EXECUTION_TIME query hint is added
+  # to inform MySQL we only have 2 seconds to execute this query
+  # The executed query will be "SELECT /*+ MAX_EXECUTION_TIME(2000) */ * FROM users"
+  client.query('SELECT * FROM users')
+
+  # MySQL only supports MAX_EXECUTION_TIME for SELECTs so no query hint here
+  client.query("INSERT INTO users(first_name) VALUES('Joe')")
+
+  sleep(3)
+
+  # We don't even execute this query because time is already expired
+  # This limit applies to all queries, including INSERTS, etc
+  client.query('SELECT * FROM users')
+end
+```
+
+Timing a Rails Controller
+---------------------------
+
+One use of a cutoff is to add a deadline to a Rails controller action.
+
+```ruby
+around_action { |_controller, action| Cutoff.wrap(2.5) { action.call } }
+```
+
+Now in your action, you can call `checkpoint!`, or if you're using the Mysql2
+patch, checkpoints will be added automatically.
+
+```ruby
+def index
+  # Do thing one
+  Cutoff.checkpoint!
+
+  # Do something else
+end
+```
+
+Consider adding a global error handler for the `Cutoff::CutoffExceededError`
+
+```ruby
+class ApplicationController < ActionController::Base
+  rescue_from Cutoff::CutoffExceededError, with: :handle_cutoff_exceeded
+
+  def handle_cutoff_exceeded
+    # Render a nice error page
+  end
+end
+```
+
+Multi-threading
+-----------------
+
+In multi-threaded environments, cutoff class methods are independent in each
+thread. That means that if you start a cutoff in one thread then start a new
+thread, the second thread _will not_ inherit the cutoff from its parent thread.
+
+```ruby
+Cutoff.wrap(6) do
+  Thread.new do
+    # This code can run as long as it wants because the class-level
+    # cutoff is independent
+
+    Cutoff.wrap(3) do
+      # However, you can start a new cutoff inside the new thread and it
+      # will not affect any other threads
+    end
+  end
+end
+```
+
+The same rules apply to fibers. Each fiber has independent class-level cutoff
+instances. This means you can use Cutoff in a multi-threaded web server or job
+runner without worrying about thread conflicts.
+
+If you want to use a single cutoff for multi-threading, you'll need to pass an
+instance of a Cutoff.
+
+```ruby
+cutoff = Cutoff.new(6)
+cutoff.checkpoint! # parent thread can call checkpoint!
+Thread.new do
+  # And the child thread can use the same cutoff
+  cutoff.checkpoint!
+end
+end
+```
+
+However, because patches use the class-level Cutoff methods, this only works
+when calling cutoff methods manually.
+
+Nested Cutoffs
+-----------------
+
+When using the Cutoff class methods, it is possible to nest multiple Cutoff
+contexts with `.wrap` or `.start`.
+
+```ruby
+Cutoff.wrap(10) do
+  # This outer block has a timeout of 10 seconds
+  Cutoff.wrap(3) do
+    # But this inner block is only allowed to take 3 seconds
+  end
+end
+```
+
+A child cutoff can never be set for longer than the remaining time of its parent
+cutoff. So if a child is created for longer than the remaining allowed time, it
+will be reduced to the remaining time of the outer cutoff.
+
+```ruby
+Cutoff.wrap(5) do
+  sleep(4)
+  # There is only 1 second remaining in the parent
+  Cutoff.wrap(3) do
+    # So this inner block will only have 1 second to execute
+  end
+end
+```
+
+About the Timer
+-------------------
+
+Cutoff tries to use the best timer available on whatever platform it's running
+on. If a monotonic clock is available, that will be used, or failing that, if
+concurrent-ruby is loaded, that will be used. If neither is available,
+`Time.now` is used.
+
+This mean that Cutoff tries its best to prevent time from travelling backwards.
+However, the clock uniformity, resolution, and stability is determined by the
+system Cutoff is running on.
+
+Manual start and stop
+----------------------
+
+If you find that `Cutoff.wrap` is too limiting for some integrations, Cutoff
+also provides the `start` and `stop` methods. Extra care is required to use
+these to prevent a cutoff from being leaked. Every `start` call must be
+accompanied by a `stop` call, otherwise the cutoff will continue to run and
+could affect a context other than the intended one.
+
+```ruby
+Cutoff.start(2.5)
+begin
+  # Execute code here
+  Cutoff.checkpoint!
+ensure
+  # Always stop in an ensure statement to make sure an exception cannot leave
+  # a cutoff running
+  Cutoff.stop
+end
+
+# Nested cutoffs are still supported
+outer = Cutoff.start(10)
+begin
+  # Outer 10s cutoff is used here
+  Cutoff.checkpoint!
+
+  inner = Cutoff.start(5)
+  begin
+    # Inner 5s cutoff is used here
+    Cutoff.checkpoint!
+  ensure
+    # Stops the inner cutoff
+    # We don't need to pass the instance here, but it does prevent some types of mistakes
+    Cutoff.stop(inner)
+  end
+ensure
+  # Stops the outer cutoff
+  Cutoff.stop(outer)
+end
+
+Cutoff.start(10)
+Cutoff.start(5)
+begin
+  # Code here
+ensure
+  # This stops all cutoffs
+  Cutoff.clear_all
+end
+```
+
+Be careful, you can easily make a mistake when using this API, so prefer `.wrap`
+when possible.
+
+Design Philosophy
+-------------------
+
+Cutoff is designed to only stop code execution at predictable points. It will
+never interrupt a running program unless:
+
+- `checkpoint!` is called
+- a network timeout is exceeded
+
+Patches such as the current Mysql2 patch are designed to ease the burden on
+developers to manually call `checkpoint!` or configure network timeouts. The
+ruby `Timeout` class is not used. See Julia Evans' post on [Why Ruby's Timeout
+is dangerous][julia_evans].
+
+Patches are only applied by explicit opt-in, and Cutoff can always be used as a
+standalone library.
+
+[julia_evans]: https://jvns.ca/blog/2015/11/27/why-rubys-timeout-is-dangerous-and-thread-dot-raise-is-terrifying/
+[kir shatrov]: https://kirshatrov.com/posts/scaling-mysql-stack-part-2-deadlines/
+[api docs]: https://www.rubydoc.info/github/justinhoward/cutoff/master

data/lib/cutoff.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal:true
+
+require_relative 'cutoff/version'
+require_relative 'cutoff/error'
+require_relative 'cutoff/patch'
+
+class Cutoff
+  CURRENT_STACK_KEY = 'cutoff_deadline_stack'
+  private_constant :CURRENT_STACK_KEY
+
+  class << self
+    # Get the current {Cutoff} if one is set
+    def current
+      Thread.current[CURRENT_STACK_KEY]&.last
+    end
+
+    # Add a new {Cutoff} to the stack
+    #
+    # This {Cutoff} will be specific to this thread
+    #
+    # If a cutoff is already started for this thread, then `start` uses the
+    # minimum of the current remaining time and the given time
+    #
+    # @param seconds [Float, Integer] The number of seconds for the cutoff. May
+    #   be overridden if there is an active cutoff and it has less remaining
+    #   time.
+    # @return [Cutoff] The {Cutoff} instance
+    def start(seconds)
+      seconds = [seconds, current.seconds_remaining].min if current
+      cutoff = Cutoff.new(seconds)
+      Thread.current[CURRENT_STACK_KEY] ||= []
+      Thread.current[CURRENT_STACK_KEY] << cutoff
+      cutoff
+    end
+
+    # Remove the top {Cutoff} from the stack
+    #
+    # @param cutoff [Cutoff] If given, the top instance will only be removed
+    #   if it matches the given cutoff instance
+    # @return [Cutoff, nil] If a cutoff was removed it is returned
+    def stop(cutoff = nil)
+      stack = Thread.current[CURRENT_STACK_KEY]
+      return unless stack
+
+      top = stack.last
+      stack.pop if cutoff.nil? || top == cutoff
+      clear_all if stack.empty?
+
+      cutoff
+    end
+
+    # Clear the entire stack for this thread
+    #
+    # @return [void]
+    def clear_all
+      Thread.current[CURRENT_STACK_KEY] = nil
+    end
+
+    # Wrap a block in a cutoff
+    #
+    # Same as calling {.start} and {.stop} manually, but safer since
+    # you can't forget to stop a cutoff and it handles exceptions raised
+    # inside the block
+    #
+    # @see .start
+    # @see .stop
+    # @return The value that returned from the block
+    def wrap(seconds)
+      cutoff = start(seconds)
+      yield cutoff
+    ensure
+      stop(cutoff)
+    end
+
+    # Raise an exception if there is an active expired cutoff
+    #
+    # Does nothing if no active cutoff is set
+    #
+    # @raise CutoffExceededError If there is an active expired cutoff
+    # @return [void]
+    def checkpoint!
+      cutoff = current
+      return unless cutoff
+
+      cutoff.checkpoint!
+    end
+
+    if defined?(Process::CLOCK_MONOTONIC_RAW)
+      # The current time
+      #
+      # If it is available, this will use a monotonic clock. This is a clock
+      # that always moves forward in time. If that is not available on this
+      # system, `Time.now` will be used
+      #
+      # @return [Float] The current time as a float
+      def now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC_RAW)
+      end
+    elsif defined?(Process::CLOCK_MONOTONIC)
+      def now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    elsif Gem.loaded_specs['concurrent-ruby']
+      require 'concurrent-ruby'
+
+      def now
+        Concurrent.monotonic_time
+      end
+    else
+      def now
+        Time.now.to_f
+      end
+    end
+  end
+
+  # @return [Float] The total number of seconds for this cutoff
+  attr_reader :allowed_seconds
+
+  # Create a new cutoff
+  #
+  # The timer starts immediately upon creation
+  #
+  # @param allowed_seconds [Integer, Float] The total number of seconds to allow
+  def initialize(allowed_seconds)
+    @allowed_seconds = allowed_seconds.to_f
+    @start_time = Cutoff.now
+  end
+
+  # The number of seconds left on the clock
+  #
+  # @return [Float] The number of seconds
+  def seconds_remaining
+    @allowed_seconds - elapsed_seconds
+  end
+
+  # The number of milliseconds left on the clock
+  #
+  # @return [Float] The number of milliseconds
+  def ms_remaining
+    seconds_remaining * 1000
+  end
+
+  # The number of seconds elapsed since this {Cutoff} was created
+  #
+  # @return [Float] The number of seconds
+  def elapsed_seconds
+    Cutoff.now - @start_time
+  end
+
+  # Has the Cutoff been exceeded?
+  #
+  # @return [Boolean] True if the timer expired
+  def exceeded?
+    seconds_remaining.negative?
+  end
+
+  # Raises an error if this Cutoff has been exceeded
+  #
+  # @raise CutoffExceededError If there is an active expired cutoff
+  # @return [void]
+  def checkpoint!
+    raise CutoffExceededError, self if exceeded?
+
+    nil
+  end
+end

data/lib/cutoff/error.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal:true
+
+class Cutoff
+  # The Cutoff base error class
+  class CutoffError < StandardError
+    private
+
+    def message_with_meta(message, **meta)
+      "#{message}: #{format_meta(**meta)}"
+    end
+
+    def format_meta(**meta)
+      meta.map { |key, value| "#{key}=#{value}" }.join(' ')
+    end
+  end
+
+  # Raised by {Cutoff#checkpoint!} if the time has been exceeded
+  class CutoffExceededError < CutoffError
+    attr_reader :cutoff
+
+    def initialize(cutoff)
+      @cutoff = cutoff
+
+      super(message_with_meta(
+        'Cutoff exceeded',
+        allowed_seconds: cutoff.allowed_seconds,
+        elapsed_seconds: cutoff.elapsed_seconds
+      ))
+    end
+  end
+end

data/lib/cutoff/patch.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal:true
+
+class Cutoff
+  # Namespace for patches that are not automatically required
+  module Patch
+  end
+end

data/lib/cutoff/patch/mysql2.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'strscan'
+require 'mysql2'
+
+class Cutoff
+  module Patch
+    # Sets the max execution time for SELECT queries if there is an active
+    # cutoff and it has time remaining
+    module Mysql2
+      # Overrides `Mysql2::Client#query` to insert a MAX_EXECUTION_TIME query
+      # hint with the remaining cutoff time
+      #
+      # If the cutoff is already exceeded, the query will not be executed and
+      # a {CutoffExceededError} will be raised
+      #
+      # @see Mysql2::Client#query
+      # @raise CutoffExceededError If the cutoff is exceeded. The query will not
+      #   be executed in this case.
+      def query(sql, options = {})
+        cutoff = Cutoff.current
+        return super unless cutoff
+
+        cutoff.checkpoint!
+        sql = QueryWithMaxTime.new(sql, cutoff.ms_remaining.ceil).to_s
+        super
+      end
+
+      # Parses a query and inserts a MAX_EXECUTION_TIME query hint if possible
+      #
+      # @private
+      class QueryWithMaxTime
+        def initialize(query, max_execution_time_ms)
+          @scanner = StringScanner.new(query.dup)
+          @max_execution_time_ms = max_execution_time_ms
+          @found_select = false
+          @found_hint = false
+          @hint_pos = nil
+          @insert_space = false
+          @insert_trailing_space = false
+        end
+
+        def to_s
+          return @scanner.string if @scanner.eos?
+
+          # Loop through tokens like "WORD " or "/* "
+          while @scanner.scan(/(\S+)\s+/)
+            # Get the word part. None of our tokens care about case
+            handle_token(@scanner[1].downcase)
+          end
+
+          return @scanner.string unless @found_select
+
+          insert_hint
+          @scanner.string
+        end
+
+        private
+
+        def hint
+          "MAX_EXECUTION_TIME(#{@max_execution_time_ms})"
+        end
+
+        def handle_token(token)
+          if token.start_with?('--')
+            line_comment
+          elsif token.start_with?('/*+')
+            hint_comment
+          elsif token.start_with?('/*')
+            block_comment
+          elsif token.start_with?('select')
+            select
+          else
+            other
+          end
+        end
+
+        def insert_hint
+          @scanner.string.insert(@hint_pos, ' ') if @insert_trailing_space
+
+          if @found_hint
+            # If we found an existing hint, insert our new hint there
+            @scanner.string.insert(@hint_pos, hint)
+          elsif @found_select
+            # Otherwise if we found a select, place our hint right after it
+            @scanner.string.insert(@hint_pos, "/*+ #{hint} */")
+          end
+
+          @scanner.string.insert(@hint_pos, ' ') if @insert_space
+        end
+
+        def line_comment
+          # \R matches cross-platform newlines
+          # so we skip until the end of the line
+          @scanner.skip_until(/\R/)
+        end
+
+        def block_comment
+          # Go back to the beginning of the comment then scan until the end
+          # This handles block comments that don't contain whitespace
+          @scanner.unscan
+          @scanner.skip_until(%r{\*/\s*})
+        end
+
+        def hint_comment
+          # We can just treat this as a normal block comment if we haven't seen
+          # a select yet
+          return block_comment unless @found_select
+
+          @found_hint = true
+          # Go back to the beginning of the comment
+          # This is so we can handle comments that don't have internal
+          # whitespace
+          @scanner.unscan
+          # Now skip past just the start of the comment so we don't detect it
+          # on the next line
+          @scanner.skip(%r{/\*\+})
+          # Scan until the end of the comment
+          # Also detect the last word and trailing whitespace if it exists
+          @scanner.scan_until(%r{(\S*)(\s*)\*/})
+          # Now step back to the beginning of the */
+          # If there was trailing whitespace, also subtract that
+          # so that we're at the start of the trailing whitespace
+          # That's where we want to put our hint
+          @hint_pos = @scanner.pos - 2 - @scanner[2].size
+          # We only want to insert an extra space to the left of our
+          # hint if there was already a hint (it's possible to have an
+          # empty hint comment). So check if there was a word there.
+          @insert_space = !@scanner[1].empty?
+
+          # Once we find our position, we're done
+          @scanner.terminate
+        end
+
+        def select
+          # If we encounter a select, we're ready to place our hint comment
+          @scanner.unscan
+          word = @scanner.scan(/\w+/)
+
+          # Make sure our word is actually select
+          # We only checked that it starts with select before
+          return other unless word.casecmp('select')
+
+          @found_select = true
+          @hint_pos = @scanner.pos
+
+          # If the select has space after it, we want to also
+          # insert one later
+          if @scanner.scan(/\s+/)
+            @insert_space = true
+          elsif @scanner.scan(/\*/)
+            # Handle SELECT* since it needs to have an extra space inserted
+            # after the hint comment
+            @insert_trailing_space = true
+          end
+        end
+
+        def other
+          # If we encounter any other token, we're done
+          # Either we found the select or we found another token
+          # that indicates we should not insert a hint
+          @scanner.terminate
+        end
+      end
+    end
+  end
+end
+
+Mysql2::Client.prepend(Cutoff::Patch::Mysql2)

data/lib/cutoff/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Cutoff
+  # @return [Gem::Version] The current version of the cutoff gem
+  def self.version
+    Gem::Version.new('0.1.0')
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: cutoff
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Justin Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-07-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.81.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.81.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.38.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.38.1
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: 
+email:
+- jmhoward0@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/cutoff.rb
+- lib/cutoff/error.rb
+- lib/cutoff/patch.rb
+- lib/cutoff/patch/mysql2.rb
+- lib/cutoff/version.rb
+homepage: https://github.com/justinhoward/cutoff
+licenses:
+- MIT
+metadata:
+  changelog_uri: https://github.com/justinhoward/cutoff/blob/master/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/cutoff/0.1.0
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Deadlines for ruby
+test_files: []