caddy 1.0.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3e8d643dfca9cc2e978b9ecd7887fea9f5b3158
-  data.tar.gz: 25837935c927e4cf99d4cac355426a0ccec8d877
+  metadata.gz: 4d0bb8c605dbc32dbcb05731e669f1ccf00f58c7
+  data.tar.gz: 664c4aca36f43b4b6a441f54eaf9ca7a25c0d9b0
 SHA512:
-  metadata.gz: 05ccf0297987d26658f8cd331d750357a92fa6f8258c462a18697e69552e99eff13df4bd33953bfebd27a17f64b5cff2cd1a5bd07f1d4c986a34c657d5f6adae
-  data.tar.gz: 6527ac465c99634d5eec1eb2f195f7c92fe58d6d310a6b84a4f5bca12975cfd54bdd0b88e053970e5a74f862b1ecf10272a5ea2b9fdb9cfa469df304ed26979e
+  metadata.gz: 5420367fd7d24dfe740513085f54e8ec63646507e687deb6b8d9de37463991023c3a417c098ff26123602153d58ec66d4bf3a4b0abb08c40b24c1cb7dc581405
+  data.tar.gz: de4e27a4e7e66d956acde7a442943268b44e11a0f1f7c193d0a4e77b96952397600dc9b91c28cd6d7e4850e9ac7594e300e1b7543c01a77317f1d98fcc904849

data/README.md

@@ -8,15 +8,18 @@ It's powered by [concurrent-ruby](https://github.com/ruby-concurrency/concurrent
 
 ```ruby
 # in your initializers (caddy.rb would be a wonderful name)
-Caddy.refresher = lambda do
-  {
-    flags: SomeFlagService.fetch_flags, # this can take a few seconds; it won't block requests when you use it later
-    cache_keys: SomeCacheKeyService.cache_keys
-  }
+Caddy[:flags].refresher = lambda do
+  SomeFlagService.fetch_flags # this can take a few seconds; it won't block requests when you use it later
 end
 
-Caddy.refresh_interval = 30.seconds # default is 60 seconds; the actual amount is smoothed slightly
-                                    # to avoid a stampeding herd of refreshes
+# you can have multiple cache stores, refreshed at different intervals
+Caddy[:cache_keys].refresher = lambda do
+  SomeCacheKeyService.cache_keys
+end
+
+Caddy[:flags].refresh_interval = 30.seconds # default is 60 seconds; the actual amount is smoothed slightly
+                                            # to avoid a stampeding herd of refreshes
+Caddy[:cache_keys].refresh_interval = 5.minutes
 
 # ... after your application forks (see the guide below for Unicorn, Puma & Spring)
 Caddy.start
@@ -24,7 +27,7 @@ Caddy.start
 # ... in a controller
 def index
   # Caddy provides a convenience method to access the cache by key; you can also access
-  # what your refresher returns directly with Caddy.cache[:flags][...]
+  # what your refresher returns directly with Caddy[:flags].cache
   if Caddy[:flags][:fuzz_bizz]
     Rails.cache.fetch("#{Caddy[:cache_keys][:global_key]}/#{Caddy[:cache_keys][:index_key]}/foo/bar") do
       # wonderful things happen here
@@ -33,6 +36,16 @@ def index
 end
 ```
 
+## Error handling
+
+As Caddy refreshers are run in threads, exceptions are not normally reported (except by default in the logs). To add a programmatic error handler:
+
+```ruby
+Caddy[:flags].refresher = -> { SomeFlagService.fetch_flags }
+Caddy.error_handler = -> (exception) { ExceptionReporter.bad_thing_happened(exception) } # global (all caches) error handler
+Caddy[:flags].error_handler = -> (exception) { SpecificExceptionReporter.worse_thing_happened(exception) } # cache-specific error reporters also supported
+```
+
 ## Using Caddy with Unicorn
 
 Start Caddy after fork:

data/lib/caddy.rb

@@ -1,75 +1,42 @@
 # frozen_string_literal: true
+require "concurrent/timer_task"
+
 require "caddy/version"
 require "caddy/task_observer"
-require "concurrent/timer_task"
+require "caddy/cache"
 
 module Caddy
   class << self
-    attr_accessor :refresher, :error_handler, :refresh_interval
+    attr_accessor :error_handler
   end
 
-  DEFAULT_REFRESH_INTERVAL = 60
-  REFRESH_INTERVAL_JITTER_PCT = 0.15
-
-  @task = nil
-  @refresh_interval = DEFAULT_REFRESH_INTERVAL
-  @_started_pid = nil
-  @_cache = nil
+  @started_pid = nil
+  @caches = Hash.new { |h, k| h[k] = Caddy::Cache.new(k) }
 
   def self.[](k)
-    cache[k]
+    @caches[k]
   end
 
-  def self.cache
-    raise "Please run `Caddy.start` before attempting to access the cache" unless @task
-    raise "Caddy cache access before initial load; allow some more time for your app to start up" unless @_cache
-
-    @_cache
+  def self.caches
+    @caches
   end
 
   def self.start
-    unless refresher && refresher.respond_to?(:call)
-      raise "Please set your cache refresher via `Caddy.refresher = -> { <code that returns a value> }`"
-    end
-
-    raise "`Caddy.refresh_interval` must be > 0" unless refresh_interval > 0
-
-    if @_started_pid && $$ != @_started_pid
+    if !@started_pid
+      @started_pid = $$
+    elsif @started_pid && $$ != @started_pid
       raise "Please run `Caddy.start` *after* forking, as the refresh thread will get killed after fork"
     end
 
-    jitter_amount = [0.5, refresh_interval * REFRESH_INTERVAL_JITTER_PCT].max
-    interval = refresh_interval + rand(-jitter_amount...jitter_amount)
-    timeout_interval = [interval - 1, 0.1].max
-
-    stop # stop any existing task from running
-
-    @task = Concurrent::TimerTask.new(
-      run_now: true,
-      execution_interval: interval,
-      timeout_interval: timeout_interval
-    ) do
-      begin
-        @_cache = refresher.call
-        @_cache.freeze if @_cache.respond_to?(:freeze)
-      rescue
-        raise
-      end
-    end
-
-    @task.add_observer(Caddy::TaskObserver.new)
-    @task.execute
-
-    @_started_pid = $$
-
-    @task.running?
+    @caches.values.each(&:start).all?
   end
 
   def self.stop
-    @task.shutdown if @task && @task.running?
+    @caches.values.each(&:stop).all?
   end
 
   def self.restart
-    stop || start
+    stop
+    start
   end
 end

data/lib/caddy/cache.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+module Caddy
+  class Cache
+    DEFAULT_REFRESH_INTERVAL = 60
+    REFRESH_INTERVAL_JITTER_PCT = 0.15
+
+    attr_accessor :refresher, :refresh_interval, :error_handler
+
+    def initialize(key)
+      @task = nil
+      @refresh_interval = DEFAULT_REFRESH_INTERVAL
+      @cache = nil
+      @key = key
+    end
+
+    def [](k)
+      cache[k]
+    end
+
+    def cache
+      raise "Please run `Caddy.start` before attempting to access the cache" unless @task && @task.running?
+
+      @cache
+    end
+
+    def start
+      unless refresher && refresher.respond_to?(:call)
+        raise "Please set your cache refresher via `Caddy[:#{@key}].refresher = -> { <code that returns a value> }`"
+      end
+
+      raise "`Caddy[:#{@key}].refresh_interval` must be > 0" unless refresh_interval > 0
+
+      jitter_amount = [0.1, refresh_interval * REFRESH_INTERVAL_JITTER_PCT].max
+      interval = refresh_interval + rand(-jitter_amount...jitter_amount)
+      timeout_interval = [interval - 1, 0.1].max
+
+      stop # stop any existing task from running
+
+      @task = Concurrent::TimerTask.new(
+        run_now: true,
+        execution_interval: interval,
+        timeout_interval: timeout_interval
+      ) do
+        begin
+          @cache = refresher.call.freeze
+        rescue
+          raise
+        end
+      end
+
+      @task.add_observer(Caddy::TaskObserver.new(error_handler, @key))
+      @task.execute
+
+      @task.running?
+    end
+
+    def stop
+      @task.shutdown if @task && @task.running?
+    end
+  end
+end

data/lib/caddy/task_observer.rb

@@ -1,15 +1,20 @@
 # frozen_string_literal: true
 module Caddy
   class TaskObserver
+    def initialize(error_handler, cache_name)
+      @error_handler = error_handler || Caddy.error_handler
+      @cache_name = cache_name
+    end
+
     def update(_, _, boom)
       return unless boom
 
-      if Caddy.error_handler
-        if Caddy.error_handler.respond_to?(:call)
+      if @error_handler
+        if @error_handler.respond_to?(:call)
           begin
-            Caddy.error_handler.call(boom)
+            @error_handler.call(boom)
           rescue => incepted_boom
-            puts_exception("Caddy error handler itself errored", incepted_boom)
+            puts_exception("Caddy error handler itself errored handling refresh for :#{@cache_name}", incepted_boom)
           end
         else
           # rubocop:disable Style/StringLiterals
@@ -17,12 +22,12 @@ module Caddy
                       ' `Caddy.error_handler = -> (e) { puts "#{e}" }`'
           # rubocop:enable Style/StringLiterals
 
-          puts_exception("Caddy refresher failed with error", boom)
+          puts_exception("Caddy refresher for :#{@cache_name} failed with error", boom)
         end
       elsif boom.is_a?(Concurrent::TimeoutError)
-        STDERR.puts "Caddy refresher timed out"
+        STDERR.puts "Caddy refresher for :#{@cache_name} timed out"
       else
-        puts_exception("Caddy refresher failed with error", boom)
+        puts_exception("Caddy refresher for :#{@cache_name} failed with error", boom)
       end
     end
 

data/lib/caddy/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Caddy
-  VERSION = "1.0.1".freeze
+  VERSION = "1.5.0".freeze
 end

data/test/caddy_test.rb

@@ -3,61 +3,104 @@ require "test_helper"
 class CaddyTest < Minitest::Test
   def setup
     Caddy.stop
-    Caddy.refresher = -> {}
-    Caddy.refresh_interval = 30
     Caddy.error_handler = nil
+
+    [:test, :test_two].each do |k|
+      Caddy[k].refresher = -> {}
+      Caddy[k].refresh_interval = 30
+      Caddy[k].error_handler = nil
+    end
+
     sleep(0.05)
   end
 
   def test_basic_lookup
-    Caddy.refresher = -> { {foo: "bar"} }
+    Caddy[:test].refresher = -> { {foo: "bar"} }
     Caddy.start
     sleep(0.1)
 
-    assert_equal "bar", Caddy[:foo]
+    assert_equal "bar", Caddy[:test][:foo]
   end
 
   def test_basic_interval_updating
     x = 0
-    Caddy.refresher = lambda do
+    Caddy[:test].refresher = lambda do
       x += 1
       {baz: x}
     end
-    Caddy.refresh_interval = 2
+    Caddy[:test].refresh_interval = 2
     Caddy.start
     sleep(3)
 
-    assert_operator Caddy[:baz], :>=, 2
+    assert_operator Caddy[:test][:baz], :>=, 2
+  end
+
+  def test_multiple_interval_updating
+    x = 0
+    y = 0
+    Caddy[:test].refresher = lambda do
+      x += 1
+      {baz: x}
+    end
+    Caddy[:test].refresh_interval = 2
+    Caddy[:test_two].refresher = lambda do
+      y += 1
+      {biz: y}
+    end
+    Caddy[:test_two].refresh_interval = 1
+    Caddy.start
+    sleep(4)
+
+    assert_operator Caddy[:test][:baz], :>=, 2
+    assert_operator Caddy[:test_two][:biz], :>=, 4
   end
 
   def test_stale_value
     ran_once = false
-    Caddy.refresher = lambda do
+    Caddy[:test].refresher = lambda do
       raise "boom" if ran_once
       ran_once = true
       {baz: "bizz"}
     end
-    Caddy.refresh_interval = 2
+    Caddy[:test].refresh_interval = 2
     Caddy.start
     sleep(3)
 
-    assert_equal "bizz", Caddy[:baz]
+    assert_equal "bizz", Caddy[:test][:baz]
+  end
+
+  def test_many_readers
+    x = 0
+    Caddy[:test].refresher = -> { {x: x += 1} }
+    Caddy[:test].refresh_interval = 0.1
+    Caddy.start
+    sleep(0.1)
+
+    Array.new(50) do
+      Thread.new do
+        200.times do
+          x = Caddy[:test][:x]
+          sleep(0.01)
+          x = Caddy[:test][:x]
+        end
+      end
+    end.each(&:join)
   end
 
   def test_restart
-    Caddy.refresher = -> { {foo: "baz"} }
+    Caddy[:test].refresher = -> { {foo: "baz"} }
     Caddy.start
     sleep(0.1)
     Caddy.stop
     Caddy.restart
     sleep(0.1)
 
-    assert_equal "baz", Caddy[:foo]
+    assert_equal "baz", Caddy[:test][:foo]
   end
 
-  def test_error_handling
+  def test_global_error_handling
     reported = nil
-    Caddy.refresher = -> { raise "boom" }
+    Caddy[:test].refresher = -> { raise "boom" }
     Caddy.error_handler = -> (ex) { reported = ex }
     Caddy.start
     sleep(0.1)
@@ -65,15 +108,25 @@ class CaddyTest < Minitest::Test
     assert_equal "boom", reported.message
   end
 
+  def test_specific_error_handling
+    reported = nil
+    Caddy[:test].refresher = -> { raise "boom" }
+    Caddy[:test].error_handler = -> (ex) { reported = ex }
+    Caddy.start
+    sleep(0.1)
+
+    assert_equal "boom", reported.message
+  end
+
   def test_incepted_error_handling
-    Caddy.refresher = -> { raise "boom" }
+    Caddy[:test].refresher = -> { raise "boom" }
     Caddy.error_handler = -> (_) { raise "boomboom" }
     Caddy.start
     sleep(0.1)
   end
 
   def test_bad_error_handler
-    Caddy.refresher = -> { raise "boom" }
+    Caddy[:test].refresher = -> { raise "boom" }
     Caddy.error_handler = "no"
     Caddy.start
     sleep(0.1)
@@ -81,9 +134,9 @@ class CaddyTest < Minitest::Test
 
   def test_timeout
     timed_out = nil
-    Caddy.refresher = -> { sleep 1 }
+    Caddy[:test].refresher = -> { sleep 1 }
     Caddy.error_handler = -> (ex) { timed_out = ex }
-    Caddy.refresh_interval = 0.5
+    Caddy[:test].refresh_interval = 0.5
     Caddy.start
     sleep(2)
 
@@ -93,8 +146,8 @@ class CaddyTest < Minitest::Test
   end
 
   def test_no_handler_timeout
-    Caddy.refresher = -> { sleep 1 }
-    Caddy.refresh_interval = 0.5
+    Caddy[:test].refresher = -> { sleep 1 }
+    Caddy[:test].refresh_interval = 0.5
     Caddy.start
     sleep(2)
     Caddy.stop
@@ -102,19 +155,19 @@ class CaddyTest < Minitest::Test
   end
 
   def test_no_handler
-    Caddy.refresher = -> { raise "boom" }
+    Caddy[:test].refresher = -> { raise "boom" }
     Caddy.start
     sleep(0.1)
   end
 
   def test_requires_refesher
-    Caddy.refresher = nil
+    Caddy[:test].refresher = nil
 
     assert_raises { Caddy.start }
   end
 
   def test_requires_positive_interval
-    Caddy.refresh_interval = -2
+    Caddy[:test].refresh_interval = -2
 
     assert_raises { Caddy.start }
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: caddy
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.5.0
 platform: ruby
 authors:
 - Nick Elser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-08 00:00:00.000000000 Z
+date: 2016-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -85,6 +85,7 @@ files:
 - docs/architecture.dot
 - docs/architecture.svg
 - lib/caddy.rb
+- lib/caddy/cache.rb
 - lib/caddy/task_observer.rb
 - lib/caddy/version.rb
 - test/caddy_test.rb