semian 0.3.0 → 0.4.0

data/Rakefile

@@ -1,6 +1,9 @@
 require 'bundler/gem_tasks'
-
-task :default => :test
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue LoadError
+end
 
 # ==========================================================
 # Packaging
@@ -9,14 +12,14 @@ task :default => :test
 GEMSPEC = eval(File.read('semian.gemspec'))
 
 require 'rubygems/package_task'
-Gem::PackageTask.new(GEMSPEC) do |pkg|
+Gem::PackageTask.new(GEMSPEC) do |_pkg|
 end
 
 # ==========================================================
 # Ruby Extension
 # ==========================================================
 
-$:.unshift File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require 'semian/platform'
 if Semian.sysv_semaphores_supported?
   require 'rake/extensiontask'
@@ -24,9 +27,10 @@ if Semian.sysv_semaphores_supported?
     ext.ext_dir = 'ext/semian'
     ext.lib_dir = 'lib/semian'
   end
-  task :build => :compile
+  task build: :compile
 else
-  task :build do; end
+  task :build do
+  end
 end
 
 # ==========================================================
@@ -35,10 +39,10 @@ end
 
 require 'rake/testtask'
 Rake::TestTask.new 'test' do |t|
-  t.libs = ['lib', 'test']
+  t.libs = %w(lib test)
   t.pattern = "test/*_test.rb"
 end
-task :test => :build
+task test: :build
 
 # ==========================================================
 # Documentation
@@ -47,3 +51,6 @@ require 'rdoc/task'
 RDoc::Task.new do |rdoc|
   rdoc.rdoc_files.include("lib/*.rb", "ext/semian/*.c")
 end
+
+task default: :test
+task default: :rubocop

data/ext/semian/extconf.rb

@@ -1,4 +1,4 @@
-$:.unshift File.expand_path("../../../lib", __FILE__)
+$LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
 
 require 'semian/platform'
 
@@ -24,7 +24,7 @@ have_func 'rb_thread_blocking_region'
 have_func 'rb_thread_call_without_gvl'
 
 $CFLAGS = "-D_GNU_SOURCE -Werror -Wall "
-if ENV.has_key?('DEBUG')
+if ENV.key?('DEBUG')
   $CFLAGS << "-O0 -g"
 else
   $CFLAGS << "-O3"

data/lib/semian.rb

@@ -31,7 +31,7 @@ require 'semian/instrumentable'
 # Resources also integrate a circuit breaker in order to fail faster and to let the
 # resource the time to recover. If `error_threshold` errors happen in the span of `error_timeout`
 # then the circuit will be opened and every attempt to acquire the resource will immediately fail.
-# 
+#
 # Once in open state, after `error_timeout` is elapsed, the ciruit will transition in the half-open state.
 # In that state a single error will fully re-open the circuit, and the circuit will transition back to the closed
 # state only after the resource is acquired `success_threshold` consecutive times.
@@ -44,7 +44,7 @@ require 'semian/instrumentable'
 #
 #    Semian.register(:mysql_shard0, tickets: 10, timeout: 0.5, error_threshold: 3, error_timeout: 10, success_threshold: 2)
 #
-# This registers a new resource called <code>:mysql_shard0</code> that has 10 tickets andd a default timeout of 500 milliseconds.
+# This registers a new resource called <code>:mysql_shard0</code> that has 10 tickets and a default timeout of 500 milliseconds.
 #
 # After 3 failures in the span of 10 seconds the circuit will be open.
 # After an additional 10 seconds it will transition to half-open.
@@ -78,7 +78,7 @@ module Semian
   OpenCircuitError = Class.new(BaseError)
 
   def semaphores_enabled?
-    !ENV['SEMIAN_SEMAPHORES_DISABLED']
+    !ENV['SEMIAN_SEMAPHORES_DISABLED'] && Semian.sysv_semaphores_supported?
   end
 
   module AdapterError
@@ -119,10 +119,12 @@ module Semian
   # Returns the registered resource.
   def register(name, tickets:, permissions: 0660, timeout: 0, error_threshold:, error_timeout:, success_threshold:, exceptions: [])
     circuit_breaker = CircuitBreaker.new(
+      name,
       success_threshold: success_threshold,
       error_threshold: error_threshold,
       error_timeout: error_timeout,
       exceptions: Array(exceptions) + [::Semian::BaseError],
+      implementation: ::Semian::Simple,
     )
     resource = Resource.new(name, tickets: tickets, permissions: permissions, timeout: timeout)
     resources[name] = ProtectedResource.new(resource, circuit_breaker)
@@ -154,11 +156,19 @@ require 'semian/circuit_breaker'
 require 'semian/protected_resource'
 require 'semian/unprotected_resource'
 require 'semian/platform'
-if Semian.sysv_semaphores_supported? && Semian.semaphores_enabled?
+require 'semian/simple_sliding_window'
+require 'semian/simple_integer'
+require 'semian/simple_state'
+if Semian.semaphores_enabled?
   require 'semian/semian'
 else
   Semian::MAX_TICKETS = 0
-  Semian.logger.info("Semian sysv semaphores are not supported on #{RUBY_PLATFORM} - all operations will no-op") unless Semian.sysv_semaphores_supported?
-  Semian.logger.info("Semian semaphores are disabled, is this what you really want? - all operations will no-op") unless Semian.semaphores_enabled?
+  unless Semian.sysv_semaphores_supported?
+    Semian.logger.info("Semian sysv semaphores are not supported on #{RUBY_PLATFORM} - all operations will no-op")
+  end
+
+  if ENV['SEMIAN_SEMAPHORES_DISABLED']
+    Semian.logger.info("Semian semaphores are disabled, is this what you really want? - all operations will no-op")
+  end
 end
 require 'semian/version'

data/lib/semian/adapter.rb

@@ -5,7 +5,7 @@ module Semian
     end
 
     def semian_resource
-      @semian_options ||= case semian_options
+      @semian_resource ||= case semian_options
       when false
         UnprotectedResource.new(semian_identifier)
       when nil

data/lib/semian/circuit_breaker.rb

@@ -1,16 +1,20 @@
 module Semian
-  class CircuitBreaker
-    attr_reader :state
+  class CircuitBreaker #:nodoc:
+    extend Forwardable
 
-    def initialize(exceptions:, success_threshold:, error_threshold:, error_timeout:)
+    def initialize(name, exceptions:, success_threshold:, error_threshold:, error_timeout:, implementation:)
+      @name = name.to_sym
       @success_count_threshold = success_threshold
       @error_count_threshold = error_threshold
       @error_timeout = error_timeout
       @exceptions = exceptions
-      reset
+
+      @errors = implementation::SlidingWindow.new(max_size: @error_count_threshold)
+      @successes = implementation::Integer.new
+      @state = implementation::State.new
     end
 
-    def acquire(&block)
+    def acquire
       raise OpenCircuitError unless request_allowed?
 
       result = nil
@@ -31,9 +35,8 @@ module Semian
       !open?
     end
 
-    def mark_failed(error)
-      push_time(@errors, @error_count_threshold, duration: @error_timeout)
-
+    def mark_failed(_error)
+      push_time(@errors, duration: @error_timeout)
       if closed?
         open if error_threshold_reached?
       elsif half_open?
@@ -43,70 +46,68 @@ module Semian
 
     def mark_success
       return unless half_open?
-      @successes += 1
+      @successes.increment
       close if success_threshold_reached?
     end
 
     def reset
-      @errors    = []
-      @successes = 0
+      @errors.clear
+      @successes.reset
       close
     end
 
+    def destroy
+      @errors.destroy
+      @successes.destroy
+      @state.destroy
+    end
+
     private
 
-    def closed?
-      state == :closed
-    end
+    def_delegators :@state, :closed?, :open?, :half_open?
+    private :closed?, :open?, :half_open?
 
     def close
       log_state_transition(:closed)
-      @state = :closed
-      @errors = []
-    end
-
-    def open?
-      state == :open
+      @state.close
+      @errors.clear
     end
 
     def open
       log_state_transition(:open)
-      @state = :open
-    end
-
-    def half_open?
-      state == :half_open
+      @state.open
     end
 
     def half_open
       log_state_transition(:half_open)
-      @state = :half_open
-      @successes = 0
+      @state.half_open
+      @successes.reset
     end
 
     def success_threshold_reached?
-      @successes >= @success_count_threshold
+      @successes.value >= @success_count_threshold
     end
 
     def error_threshold_reached?
-      @errors.count == @error_count_threshold
+      @errors.size == @error_count_threshold
     end
 
     def error_timeout_expired?
-      @errors.last && (@errors.last + @error_timeout < Time.now)
+      time_ms = @errors.last
+      time_ms && (Time.at(time_ms / 1000) + @error_timeout < Time.now)
     end
 
-    def push_time(window, max_size, duration:, time: Time.now)
-      window.shift while window.first && window.first + duration < time
-      window.shift if window.size == max_size
-      window << time
+    def push_time(window, duration:, time: Time.now)
+      # The sliding window stores the integer amount of milliseconds since epoch as a timestamp
+      window.shift while window.first && window.first / 1000 + duration < time.to_i
+      window << (time.to_f * 1000).to_i
     end
 
     def log_state_transition(new_state)
-      return if @state.nil? || new_state == @state
+      return if @state.nil? || new_state == @state.value
 
-      str = "[#{self.class.name}] State transition from #{@state} to #{new_state}."
-      str << " success_count=#{@successes} error_count=#{@errors.count}"
+      str = "[#{self.class.name}] State transition from #{@state.value} to #{new_state}."
+      str << " success_count=#{@successes.value} error_count=#{@errors.size}"
       str << " success_count_threshold=#{@success_count_threshold} error_count_threshold=#{@error_count_threshold}"
       str << " error_timeout=#{@error_timeout} error_last_at=\"#{@error_last_at}\""
       Semian.logger.info(str)

data/lib/semian/mysql2.rb

@@ -32,6 +32,12 @@ module Semian
     DEFAULT_HOST = 'localhost'
     DEFAULT_PORT = 3306
 
+    QUERY_WHITELIST = Regexp.union(
+      /\A\s*ROLLBACK/i,
+      /\A\s*COMMIT/i,
+      /\A\s*RELEASE\s+SAVEPOINT/i,
+    )
+
     # The naked methods are exposed as `raw_query` and `raw_connect` for instrumentation purpose
     def self.included(base)
       base.send(:alias_method, :raw_query, :query)
@@ -53,11 +59,25 @@ module Semian
     end
 
     def query(*args)
-      acquire_semian_resource(adapter: :mysql, scope: :query) { raw_query(*args) }
+      if query_whitelisted?(*args)
+        raw_query(*args)
+      else
+        acquire_semian_resource(adapter: :mysql, scope: :query) { raw_query(*args) }
+      end
     end
 
     private
 
+    def query_whitelisted?(sql, *)
+      QUERY_WHITELIST =~ sql
+    rescue ArgumentError
+      # The above regexp match can fail if the input SQL string contains binary
+      # data that is not recognized as a valid encoding, in which case we just
+      # return false.
+      return false unless sql.valid_encoding?
+      raise
+    end
+
     def connect(*args)
       acquire_semian_resource(adapter: :mysql, scope: :connection) { raw_connect(*args) }
     end

data/lib/semian/net_http.rb

@@ -0,0 +1,95 @@
+require 'semian'
+require 'semian/adapter'
+
+module Net
+  ProtocolError.include(::Semian::AdapterError)
+
+  class SemianError < ::Net::ProtocolError
+    def initialize(semian_identifier, *args)
+      super(*args)
+      @semian_identifier = semian_identifier
+    end
+  end
+
+  ResourceBusyError = Class.new(SemianError)
+  CircuitOpenError = Class.new(SemianError)
+end
+
+module Semian
+  module NetHTTP
+    include Semian::Adapter
+
+    ResourceBusyError = ::Net::ResourceBusyError
+    CircuitOpenError = ::Net::CircuitOpenError
+
+    def semian_configuration
+      Semian::NetHTTP.retrieve_semian_configuration(address, port)
+    end
+
+    def semian_identifier
+      "nethttp_#{semian_configuration[:name]}"
+    end
+
+    DEFAULT_ERRORS = [
+      ::Timeout::Error, # includes ::Net::ReadTimeout and ::Net::OpenTimeout
+      ::TimeoutError, # alias for above
+      ::SocketError,
+      ::Net::HTTPBadResponse,
+      ::Net::HTTPHeaderSyntaxError,
+      ::Net::ProtocolError,
+      ::EOFError,
+      ::IOError,
+      ::SystemCallError, # includes ::Errno::EINVAL, ::Errno::ECONNRESET, ::Errno::ECONNREFUSED, ::Errno::ETIMEDOUT, and more
+    ].freeze # Net::HTTP can throw many different errors, this tries to capture most of them
+
+    # The naked methods are exposed as `raw_query` and `raw_connect` for instrumentation purpose
+    def self.included(base)
+      base.send(:alias_method, :raw_request, :request)
+      base.send(:remove_method, :request)
+
+      base.send(:alias_method, :raw_connect, :connect)
+      base.send(:remove_method, :connect)
+    end
+
+    class << self
+      attr_accessor :semian_configuration
+      attr_accessor :exceptions
+
+      def retrieve_semian_configuration(host, port)
+        @semian_configuration.call(host, port) if @semian_configuration.respond_to?(:call)
+      end
+
+      def reset_exceptions
+        self.exceptions = Semian::NetHTTP::DEFAULT_ERRORS.dup
+      end
+    end
+
+    Semian::NetHTTP.reset_exceptions
+
+    def raw_semian_options
+      options = semian_configuration
+      options = options.dup unless options.nil?
+      options
+    end
+
+    def resource_exceptions
+      Semian::NetHTTP.exceptions
+    end
+
+    def disabled?
+      semian_configuration.nil?
+    end
+
+    def connect
+      return raw_connect if disabled?
+      acquire_semian_resource(adapter: :http, scope: :connection) { raw_connect }
+    end
+
+    def request(req, body = nil, &block)
+      return raw_request(req, body, &block) if disabled?
+      acquire_semian_resource(adapter: :http, scope: :query) { raw_request(req, body, &block) }
+    end
+  end
+end
+
+Net::HTTP.include(Semian::NetHTTP)

data/lib/semian/protected_resource.rb

@@ -5,14 +5,19 @@ module Semian
     extend Forwardable
 
     def_delegators :@resource, :destroy, :count, :semid, :tickets, :name
-    def_delegators :@circuit_breaker, :reset, :mark_failed, :request_allowed?
+    def_delegators :@circuit_breaker, :reset, :mark_failed, :mark_success, :request_allowed?
 
     def initialize(resource, circuit_breaker)
       @resource = resource
       @circuit_breaker = circuit_breaker
     end
 
-    def acquire(timeout: nil, scope: nil, adapter: nil, &block)
+    def destroy
+      @resource.destroy
+      @circuit_breaker.destroy
+    end
+
+    def acquire(timeout: nil, scope: nil, adapter: nil)
       @circuit_breaker.acquire do
         begin
           @resource.acquire(timeout: timeout) do

data/lib/semian/resource.rb

@@ -2,7 +2,7 @@ module Semian
   class Resource #:nodoc:
     attr_reader :tickets, :name
 
-    def initialize(name, tickets: , permissions: 0660, timeout: 0)
+    def initialize(name, tickets:, permissions: 0660, timeout: 0)
       _initialize(name, tickets, permissions, timeout) if respond_to?(:_initialize)
       @name = name
       @tickets = tickets