arturo 2.5.0 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2f5b242fbe7537f790c6e07e36c7cfe6bc993b7ca1862c4abae72731d7139ae
-  data.tar.gz: 4e7fbb2a7eb1e21acd51a270474f76a45ba03291051929111e6326ae6f7702c5
+  metadata.gz: bbc3960e60444e79f01132e5ce7aa3a52ec0a95e45218bf69a7d215b5e4b1af8
+  data.tar.gz: 1b999b93f95b7f4a388b50fad8f029727fccf7cf1a599b24ca1b15c2b293f000
 SHA512:
-  metadata.gz: 21f44a384cb1fc1a27965425322ed1f5013ffb522ac8ac413eea49ea2249921b31a8ad3bd4221b39b3fae5cf5e77151e497cdb84b10f753a72fd256ff87ff79f
-  data.tar.gz: 57101d806ab3645e49efb7c575a491081999343b452c74fbb956b9fee0e93e9015259821e2ffe71f2f230a5e881423cdce98c7bd2750825a366ae33b46e15074
+  metadata.gz: c6d4d6fc203bc4b40a01170a19b0a155b929f137af63c0fef84cf98f0a543ac1a4cea34c23d042c3872611621910ad0a6481570f78e0f012abeba041c815abaa
+  data.tar.gz: d73e30ce3fb43583ca4d17aba91a24d9fb796117e8c1b3cad57d8afdf284a4904ec0b95b4a05b371c7e9ef1a201d54ad6fa5e4425da6b406ea5ce49d6680e828

data/README.md

@@ -102,6 +102,7 @@ rake db:migrate
 Open up the newly-generated `config/initializers/arturo_initializer.rb`.
 There are configuration options for the following:
 
+ * logging capabilities (see [logging](#logging))
  * the method that determines whether a user has permission to manage features
    (see [admin permissions](#adminpermissions))
  * the method that returns the object that has features
@@ -126,6 +127,15 @@ work with you on support for your favorite framework.
 
 ## Deep-Dive
 
+### <span id='logging'>Logging</span>
+
+You can provide a logger in order to inspect Arturo usage.
+A potential implementation for Rails would be:
+
+```Ruby
+Arturo.logger = Rails.logger
+```
+
 ### <span id='adminpermissions'>Admin Permissions</span>
 
 `Arturo::FeatureManagement#may_manage_features?` is a method that is run in
@@ -314,6 +324,11 @@ Arturo::Feature.warm_cache!
 
 This will pre-fetch all `Feature`s and put them in the cache.
 
+To use the current cache state when you can't fetch updates from origin:
+
+```Ruby
+Arturo::Feature.extend_cache_on_failure = true
+```
 
 The following is the **intended** support for integration with view caching:
 

data/lib/arturo.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module Arturo
-
+  require 'arturo/null_logger'
   require 'arturo/special_handling'
   require 'arturo/feature_availability'
   require 'arturo/feature_management'
@@ -16,5 +16,13 @@ module Arturo
       f = self::Feature.to_feature(feature_name)
       f && f.enabled_for?(recipient)
     end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def logger
+      @logger || NullLogger.new
+    end
   end
 end

data/lib/arturo/feature.rb

@@ -15,7 +15,7 @@ module Arturo
     attr_readonly :symbol
 
     validates_presence_of :symbol, :deployment_percentage
-    validates_uniqueness_of :symbol, :allow_blank => true
+    validates_uniqueness_of :symbol, :allow_blank => true, :case_sensitive => false
     validates_numericality_of :deployment_percentage,
                                             :only_integer => true,
                                             :allow_blank => true,

data/lib/arturo/feature_caching.rb

@@ -37,15 +37,21 @@ module Arturo
       class << base
         prepend PrependMethods
         attr_accessor :cache_ttl, :feature_cache, :feature_caching_strategy
+        attr_writer :extend_cache_on_failure
       end
       base.send(:after_save) do |f|
         f.class.feature_caching_strategy.expire(f.class.feature_cache, f.symbol.to_sym) if f.class.caches_features?
       end
       base.cache_ttl = 0
+      base.extend_cache_on_failure = false
       base.feature_cache = Arturo::FeatureCaching::Cache.new
       base.feature_caching_strategy = AllStrategy
     end
 
+    def extend_cache_on_failure?
+      !!@extend_cache_on_failure
+    end
+
     def caches_features?
       self.cache_ttl.to_i > 0
     end
@@ -56,13 +62,20 @@ module Arturo
 
     class AllStrategy
       class << self
+        ##
+        # @param cache [Arturo::Cache] cache backend
+        # @param symbol [Symbol] arturo identifier
+        # @return [Arturo::Feature, Arturo::NoSuchFeature] 
+        #
         def fetch(cache, symbol, &block)
-          features = cache.read("arturo.all")
-
-          unless cache_is_current?(cache, features)
-            features = Hash[Arturo::Feature.all.map { |f| [f.symbol.to_sym, f] }]
-            mark_as_current!(cache)
-            cache.write("arturo.all", features, :expires_in => Arturo::Feature.cache_ttl * 10)
+          existing_features = cache.read("arturo.all")
+
+          features = if cache_is_current?(cache, existing_features)
+            existing_features
+          else
+            arturos_from_origin(fallback: existing_features).tap do |updated_features|
+              update_and_extend_cache!(cache, updated_features)
+            end
           end
 
           features[symbol] || Arturo::NoSuchFeature.new(symbol)
@@ -74,15 +87,85 @@ module Arturo
 
         private
 
+        ##
+        # @param fallback [Hash] features to use on database failure
+        # @return [Hash] updated features from origin or fallback
+        # @raise [ActiveRecord::ActiveRecordError] on database failure
+        #   without cache extension option
+        #
+        def arturos_from_origin(fallback:)
+          Hash[Arturo::Feature.all.map { |f| [f.symbol.to_sym, f] }]
+        rescue ActiveRecord::ActiveRecordError
+          raise unless Arturo::Feature.extend_cache_on_failure?
+
+          if fallback.blank?
+            log_empty_cache
+            raise
+          else
+            log_stale_cache
+            fallback
+          end
+        end
+
+        ##
+        # @return [Boolean] whether the current cache has to be updated from origin
+        # @raise [ActiveRecord::ActiveRecordError] on database failure
+        #   without cache extension option
+        #
         def cache_is_current?(cache, features)
           return unless features
           return true if cache.read("arturo.current")
-          return false if features.values.map(&:updated_at).compact.max != Arturo::Feature.maximum(:updated_at)
+
+          begin
+            return false if origin_changed?(features)  
+          rescue ActiveRecord::ActiveRecordError
+            raise unless Arturo::Feature.extend_cache_on_failure?
+
+            if features.blank?
+              log_empty_cache
+              raise
+            else
+              log_stale_cache
+              update_and_extend_cache!(cache, features)
+            end
+
+            return true
+          end
           mark_as_current!(cache)
         end
 
+        def formatted_log(namespace, msg)
+          "[Arturo][#{namespace}] #{msg}"
+        end
+
+        def log_empty_cache
+          Arturo.logger.error(formatted_log('extend_cache_on_failure', 'Fallback cache is empty'))
+        end
+
+        def log_stale_cache
+          Arturo.logger.warn(formatted_log('extend_cache_on_failure', 'Falling back to stale cache'))
+        end
+
+        ##
+        # @return [True]
+        #
         def mark_as_current!(cache)
-          cache.write("arturo.current", true, :expires_in => Arturo::Feature.cache_ttl)
+          cache.write("arturo.current", true, expires_in: Arturo::Feature.cache_ttl)
+        end
+
+        ##
+        # The Arturo origin might return a big payload, so checking for the latest
+        # update is a cheaper operation.
+        #
+        # @return [Boolean] if origin has been updated since the last cache update.
+        #
+        def origin_changed?(features)
+          features.values.map(&:updated_at).compact.max != Arturo::Feature.maximum(:updated_at)
+        end
+
+        def update_and_extend_cache!(cache, features)
+          mark_as_current!(cache)
+          cache.write("arturo.all", features, expires_in: Arturo::Feature.cache_ttl * 10)
         end
       end
     end
@@ -92,7 +175,7 @@ module Arturo
         if feature = cache.read("arturo.#{symbol}")
           feature
         else
-          cache.write("arturo.#{symbol}", yield || Arturo::NoSuchFeature.new(symbol), :expires_in => Arturo::Feature.cache_ttl)
+          cache.write("arturo.#{symbol}", yield || Arturo::NoSuchFeature.new(symbol), expires_in: Arturo::Feature.cache_ttl)
         end
       end
 

data/lib/arturo/null_logger.rb

@@ -0,0 +1,8 @@
+module Arturo
+  class NullLogger
+    %w[info debug error fatal warn].each do |level|
+      define_method level do |_message|
+      end
+    end
+  end
+end

data/lib/arturo/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Arturo
-  VERSION = '2.5.0'
+  VERSION = '2.5.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arturo
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.5.1
 platform: ruby
 authors:
 - James A. Rosen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-18 00:00:00.000000000 Z
+date: 2020-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -168,6 +168,7 @@ files:
 - lib/arturo/feature_params_support.rb
 - lib/arturo/middleware.rb
 - lib/arturo/no_such_feature.rb
+- lib/arturo/null_logger.rb
 - lib/arturo/special_handling.rb
 - lib/arturo/test_support.rb
 - lib/arturo/version.rb