semian 0.8.9 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe152464771999d2c44406ecfc6b9211f3288c52a0c8282175474c6a08898e03
-  data.tar.gz: 4ba4c7224d8da1fad03de8e47793639f85e9f714e57ce04534da7d06ba1d66bf
+  metadata.gz: 426aa6c4392e70e79cbf478827dcdccbc1a468f0f19b2a5e42b885584a389b00
+  data.tar.gz: df5c7c0ca8e80879c1d1d1a5cc46400c2de841e5809ea2396cc91941f222fa05
 SHA512:
-  metadata.gz: fe5c8eccd45220845c26fbf67e91a328ca049ca91ed3e832461928bcadcca28b42951b84dcb200e618588f2d7715f61d08110b9238d110e5258bb2876fe402f4
-  data.tar.gz: 1b7e9d5f65abcaeca11d3d2ec6ab73f5247bf6cdb4c1e5739ac621c31144deed8d8fe9a35b5ffaec9f6ae6807551fab5bf421b34273518fbe5812768241f922e
+  metadata.gz: da18cc34e1c36d18904cbb584a9c7a03fd32afa976f27a6ed227b62e4ebb64065ea38a36ac951d0cade1c72b115143c3b24d6299b28de0927c78e52379205f17
+  data.tar.gz: 1e4dd82c16f7717022e65d4c722a28b4bd06490cbf347dfbe0f9fafd5652b615162f884a6dea04ad5ec5314986f7b0aad3abda8205cf2cc34b434416b001d0ed

data/ext/semian/resource.c

@@ -240,6 +240,12 @@ semian_resource_alloc(VALUE klass)
   return obj;
 }
 
+VALUE
+semian_resource_in_use(VALUE self)
+{
+  return Qtrue;
+}
+
 static VALUE
 cleanup_semian_resource_acquire(VALUE self)
 {

data/ext/semian/resource.h

@@ -126,4 +126,8 @@ semian_resource_unregister_worker(VALUE self);
 VALUE
 semian_resource_alloc(VALUE klass);
 
+// Returns true if the resource is in use
+VALUE
+semian_resource_in_use(VALUE self);
+
 #endif //SEMIAN_RESOURCE_H

data/ext/semian/semian.c

@@ -52,6 +52,7 @@ void Init_semian()
   rb_define_method(cResource, "destroy", semian_resource_destroy, 0);
   rb_define_method(cResource, "reset_registered_workers!", semian_resource_reset_workers, 0);
   rb_define_method(cResource, "unregister_worker", semian_resource_unregister_worker, 0);
+  rb_define_method(cResource, "in_use?", semian_resource_in_use, 0);
 
   id_wait_time = rb_intern("wait_time");
   id_timeout = rb_intern("timeout");

data/lib/semian.rb

@@ -13,6 +13,7 @@ require 'semian/unprotected_resource'
 require 'semian/simple_sliding_window'
 require 'semian/simple_integer'
 require 'semian/simple_state'
+require 'semian/lru_hash'
 
 #
 # === Overview
@@ -89,6 +90,10 @@ module Semian
   InternalError = Class.new(BaseError)
   OpenCircuitError = Class.new(BaseError)
 
+  attr_accessor :maximum_lru_size, :minimum_lru_time
+  self.maximum_lru_size = 500
+  self.minimum_lru_time = 300
+
   def issue_disabled_semaphores_warning
     return if defined?(@warning_issued)
     @warning_issued = true
@@ -216,7 +221,7 @@ module Semian
 
   # Retrieves a hash of all registered resources.
   def resources
-    @resources ||= {}
+    @resources ||= LRUHash.new
   end
 
   # Retrieves a hash of all registered resource consumers.
@@ -226,7 +231,16 @@ module Semian
 
   def reset!
     @consumers = {}
-    @resources = {}
+    @resources = LRUHash.new
+  end
+
+  def thread_safe?
+    return @thread_safe if defined?(@thread_safe)
+    @thread_safe = true
+  end
+
+  def thread_safe=(thread_safe)
+    @thread_safe = thread_safe
   end
 
   private
@@ -235,7 +249,6 @@ module Semian
     circuit_breaker = options.fetch(:circuit_breaker, true)
     return unless circuit_breaker
     require_keys!([:success_threshold, :error_threshold, :error_timeout], options)
-    implementation = options[:thread_safety_disabled] ? ::Semian::Simple : ::Semian::ThreadSafe
 
     exceptions = options[:exceptions] || []
     CircuitBreaker.new(
@@ -245,10 +258,26 @@ module Semian
       error_timeout: options[:error_timeout],
       exceptions: Array(exceptions) + [::Semian::BaseError],
       half_open_resource_timeout: options[:half_open_resource_timeout],
-      implementation: implementation,
+      implementation: implementation(**options),
     )
   end
 
+  def implementation(**options)
+    # thread_safety_disabled will be replaced by a global setting
+    # Semian is thread safe by default. It is possible
+    # to modify the value by using Semian.thread_safe=
+    unless options[:thread_safety_disabled].nil?
+      logger.info(
+        "NOTE: thread_safety_disabled will be replaced by a global setting" \
+        "Semian is thread safe by default. It is possible" \
+        "to modify the value by using Semian.thread_safe=",
+      )
+    end
+
+    thread_safe = options[:thread_safety_disabled].nil? ? Semian.thread_safe? : !options[:thread_safety_disabled]
+    thread_safe ? ::Semian::ThreadSafe : ::Semian::Simple
+  end
+
   def create_bulkhead(name, **options)
     bulkhead = options.fetch(:bulkhead, true)
     return unless bulkhead

data/lib/semian/circuit_breaker.rb

@@ -78,6 +78,11 @@ module Semian
       @state.destroy
     end
 
+    def in_use?
+      return false if error_timeout_expired?
+      @errors.size > 0
+    end
+
     private
 
     def transition_to_close

data/lib/semian/instrumentable.rb

@@ -9,6 +9,12 @@ module Semian
       subscribers.delete(name)
     end
 
+    # Args:
+    #   event (string)
+    #   resource (Object)
+    #   scope (string)
+    #   adapter (string)
+    #   payload (optional)
     def notify(*args)
       subscribers.values.each { |subscriber| subscriber.call(*args) }
     end

data/lib/semian/lru_hash.rb

@@ -0,0 +1,160 @@
+class LRUHash
+  # This LRU (Least Recently Used) hash will allow
+  # the cleaning of resources as time goes on.
+  # The goal is to remove the least recently used resources
+  # everytime we set a new resource. A default window of
+  # 5 minutes will allow empty item to stay in the hash
+  # for a maximum of 5 minutes
+  extend Forwardable
+  def_delegators :@table, :size, :count, :empty?, :values
+  attr_reader :table
+
+  class NoopMutex
+    def synchronize(*)
+      yield
+    end
+
+    def try_lock
+      true
+    end
+
+    def unlock
+      true
+    end
+
+    def locked?
+      true
+    end
+
+    def owned?
+      true
+    end
+  end
+
+  def keys
+    @lock.synchronize { @table.keys }
+  end
+
+  def clear
+    @lock.synchronize { @table.clear }
+  end
+
+  # Create an LRU hash
+  #
+  # Arguments:
+  #   +max_size+ The maximum size of the table
+  #   +min_time+ The minimum time a resource can live in the cache
+  #
+  # Note:
+  #   The +min_time+ is a stronger guarantee than +max_size+. That is, if there are
+  #   more than +max_size+ entries in the cache, but they've all been updated more
+  #   recently than +min_time+, the garbage collection will not remove them and the
+  #   cache can grow without bound. This usually means that you have many active
+  #   circuits to disparate endpoints (or your circuit names are bad).
+  #   If the max_size is 0, the garbage collection will be very aggressive and
+  #   potentially computationally expensive.
+  def initialize(max_size: Semian.maximum_lru_size, min_time: Semian.minimum_lru_time)
+    @max_size = max_size
+    @min_time = min_time
+    @table = {}
+    @lock =
+      if Semian.thread_safe?
+        Mutex.new
+      else
+        NoopMutex.new
+      end
+  end
+
+  def set(key, resource)
+    @lock.synchronize do
+      @table.delete(key)
+      @table[key] = resource
+      resource.updated_at = Time.now
+    end
+    clear_unused_resources if @table.length > @max_size
+  end
+
+  # This method uses the property that "Hashes enumerate their values in the
+  # order that the corresponding keys were inserted." Deleting a key and
+  # re-inserting it effectively moves it to the front of the cache.
+  # Update the `updated_at` field so we can use it later do decide if the
+  # resource is "in use".
+  def get(key)
+    @lock.synchronize do
+      found = @table.delete(key)
+      if found
+        @table[key] = found
+        found.updated_at = Time.now
+      end
+      found
+    end
+  end
+
+  def delete(key)
+    @lock.synchronize do
+      @table.delete(key)
+    end
+  end
+
+  def []=(key, resource)
+    set(key, resource)
+  end
+
+  def [](key)
+    get(key)
+  end
+
+  private
+
+  def clear_unused_resources
+    payload = {
+        size: @table.size,
+        examined: 0,
+        cleared: 0,
+        elapsed: nil,
+    }
+    timer_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+    ran = try_synchronize do
+      # Clears resources that have not been used in the last 5 minutes.
+
+      stop_time = Time.now - @min_time # Don't process resources updated after this time
+      @table.each do |_, resource|
+        payload[:examined] += 1
+
+        # The update times of the resources in the LRU are monotonically increasing,
+        # time, so we can stop looking once we find the first resource with an
+        # update time after the stop_time.
+        break if resource.updated_at > stop_time
+
+        next if resource.in_use?
+
+        resource = @table.delete(resource.name)
+        if resource
+          payload[:cleared] += 1
+          resource.destroy
+        end
+      end
+    end
+
+    if ran
+      payload[:elapsed] = Process.clock_gettime(Process::CLOCK_MONOTONIC) - timer_start
+      Semian.notify(:lru_hash_gc, self, nil, nil, payload)
+    end
+  end
+
+  EXCEPTION_NEVER = {Exception => :never}.freeze
+  EXCEPTION_IMMEDIATE = {Exception => :immediate}.freeze
+  private_constant :EXCEPTION_NEVER
+  private_constant :EXCEPTION_IMMEDIATE
+
+  def try_synchronize
+    Thread.handle_interrupt(EXCEPTION_NEVER) do
+      return false unless @lock.try_lock
+      Thread.handle_interrupt(EXCEPTION_IMMEDIATE) { yield }
+      true
+    ensure
+      @lock.unlock if @lock.owned?
+    end
+  end
+end

data/lib/semian/protected_resource.rb

@@ -7,11 +7,13 @@ module Semian
                    :open?, :closed?, :half_open?
 
     attr_reader :bulkhead, :circuit_breaker, :name
+    attr_accessor :updated_at
 
     def initialize(name, bulkhead, circuit_breaker)
       @name = name
       @bulkhead = bulkhead
       @circuit_breaker = circuit_breaker
+      @updated_at = Time.now
     end
 
     def destroy
@@ -28,6 +30,10 @@ module Semian
       end
     end
 
+    def in_use?
+      circuit_breaker&.in_use? || bulkhead&.in_use?
+    end
+
     private
 
     def acquire_circuit_breaker(scope, adapter, resource)

data/lib/semian/resource.rb

@@ -5,7 +5,7 @@ module Semian
     class << Semian::Resource
       # Ensure that there can only be one resource of a given type
       def instance(*args)
-        Semian.resources[args.first] ||= new(*args)
+        Semian.resources[args.first] ||= ProtectedResource.new(args.first, new(*args), nil)
       end
     end
 
@@ -51,5 +51,9 @@ module Semian
     def key
       '0x00000000'
     end
+
+    def in_use?
+      false
+    end
   end
 end

data/lib/semian/unprotected_resource.rb

@@ -3,9 +3,11 @@ module Semian
   # the semian configuration of an `Adapter` is missing or explicitly disabled
   class UnprotectedResource
     attr_reader :name
+    attr_accessor :updated_at
 
     def initialize(name)
       @name = name
+      @updated_at = Time.now
     end
 
     def registered_workers
@@ -63,5 +65,9 @@ module Semian
     def circuit_breaker
       nil
     end
+
+    def in_use?
+      true
+    end
   end
 end

data/lib/semian/version.rb

@@ -1,3 +1,3 @@
 module Semian
-  VERSION = '0.8.9'
+  VERSION = '0.9.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: semian
 version: !ruby/object:Gem::Version
-  version: 0.8.9
+  version: 0.9.0
 platform: ruby
 authors:
 - Scott Francis
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-02 00:00:00.000000000 Z
+date: 2019-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -166,6 +166,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: memory_profiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-memory
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |2
       A Ruby C extention that is used to control access to shared resources
       across process boundaries with SysV semaphores.
@@ -190,6 +218,7 @@ files:
 - lib/semian/circuit_breaker.rb
 - lib/semian/grpc.rb
 - lib/semian/instrumentable.rb
+- lib/semian/lru_hash.rb
 - lib/semian/mysql2.rb
 - lib/semian/net_http.rb
 - lib/semian/platform.rb