circuitry 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aabb7e5d67924cf49e3d6efdd5f34c27d4d850f6
-  data.tar.gz: b63bad1d70be23cec5c666b699f8473b25a2d7cb
+  metadata.gz: 7d3cb7574969d248940e91c6fbd01644acde00f1
+  data.tar.gz: 42d00ec555e5d84515a7715ffb9386336864ed28
 SHA512:
-  metadata.gz: 01e354ad6cfaccaf54184d932714609fbad3e95c9f0a35137e756abe5448fc4fda5b7a8f52333d7dc7f05e4b80d4d2cb2c3a30b52e271e90cc70ddd2e6efd4ab
-  data.tar.gz: 146e463dc1f63ea887ec99ffbd350d9b28d9f3aff2d96fca12ce407c200a2f3a1480ce2b4be15747980f533ec00e2716854607ec53e46249b6a705e74d137bcf
+  metadata.gz: d14efee260aefebf4b7c0448d67ac318d5b7d3970f4af9e7724342208d054d134ccb315bb9c112d971c7aee8b8df0378e1df715d33e74c6d98c8edc1bea39d38
+  data.tar.gz: 592e95bbf220f32c9cc5ac0891347b513d8b4f5dee94b17395fe3a07fcba03b2f04a02ff478864944681e894cf0d197a0f283032d7941e3f6808de7b98b8beef

data/README.md

@@ -36,7 +36,7 @@ Circuitry.config do |c|
     HoneyBadger.notify(error)
     HoneyBadger.flush
   end
-  c.lock_strategy = Circuitry::Lock::Redis.new(url: 'redis://localhost:6379')
+  c.lock_strategy = Circuitry::Locks::Redis.new(url: 'redis://localhost:6379')
   c.publish_async_strategy = :batch
   c.subscribe_async_strategy = :thread
 end
@@ -55,7 +55,7 @@ Available configuration options include:
 * `error_handler`: An object that responds to `call` with two arguments: the
   deserialized message contents and the topic name used when publishing to SNS.
   *(optional, default: `nil`)*
-* `:lock_strategy` - The store used to ensure that no duplicate messages are
+* `lock_strategy` - The store used to ensure that no duplicate messages are
   processed.  Please refer to the [Lock Strategies](#lock-strategies) section for
   more details regarding this option.  *(default: `Circuitry::Locks::Memory.new`)*
 * `publish_async_strategy`: One of `:fork`, `:thread`, or `:batch` that
@@ -247,7 +247,7 @@ The circuitry gem handles this by caching SQS message IDs: first via a "soft
 lock" that denotes the message is about to be processed, then via a "hard lock"
 that denotes the message has finished processing.
 
-The soft lock has a default TTL of 15 minutes (a seemingly sane amount of time
+The soft lock has a default TTL of 5 minutes (a seemingly sane amount of time
 during which processing most queue messages should certainly be able to
 complete), while the hard lock has a default TTL of 24 hours (based upon
 [a suggestion by an AWS employee](https://forums.aws.amazon.com/thread.jspa?threadID=140782#507605)).
@@ -256,7 +256,7 @@ The soft and hard TTL values can be changed by passing a `:soft_ttl` or
 that a lock should persist.  For example:
 
 ```ruby
-Circuitry.config.lock_strategy = Circuitry::Lock::Memory.new(
+Circuitry.config.lock_strategy = Circuitry::Locks::Memory.new(
     soft_ttl: 10 * 60,      # 10 minutes
     hard_ttl: 48 * 60 * 60  # 48 hours
 )
@@ -271,7 +271,7 @@ multiple subscriber processes or if expecting a high throughput that would resul
 in a large amount of memory consumption.
 
 ```ruby
-Circuitry::Lock::Memory.new
+Circuitry::Locks::Memory.new
 ```
 
 #### Redis
@@ -284,7 +284,7 @@ redis connection options to the lock in the same way that you would when buildin
 a new `Redis` object.
 
 ```ruby
-Circuitry::Lock::Redis.new(url: 'redis://localhost:6379')
+Circuitry::Locks::Redis.new(url: 'redis://localhost:6379')
 ```
 
 The second way is to pass in a `:client` option that specifies the redis client
@@ -294,7 +294,7 @@ or utilizing [hiredis](https://github.com/redis/hiredis-rb).
 
 ```ruby
 client = Redis.new(url: 'redis://localhost:6379')
-Circuitry::Lock::Redis.new(client: client)
+Circuitry::Locks::Redis.new(client: client)
 ```
 
 #### Memcache
@@ -308,7 +308,7 @@ building a new `Dalli::Client` object.  The special `host` option will be treate
 as the memcache host, just as the first argument to `Dalli::Client`.
 
 ```ruby
-Circuitry::Lock::Memcache.new(host: 'localhost:11211', namespace: '...')
+Circuitry::Locks::Memcache.new(host: 'localhost:11211', namespace: '...')
 ```
 
 The second way is to pass in a `:client` option that specifies the dalli client
@@ -316,7 +316,7 @@ itself.  This is useful for sharing an existing memcache connection.
 
 ```ruby
 client = Dalli::Client.new('localhost:11211', namespace: '...')
-Circuitry::Lock::Memcache.new(client: client)
+Circuitry::Locks::Memcache.new(client: client)
 ```
 
 #### NOOP
@@ -329,7 +329,7 @@ messages.  Please refer to the Amazon SQS documentation pertaining to the
 #### Custom
 
 It's also possible to roll your own lock strategy.  Simply create a class that
-includes (or module that extends) `Circuitry::Lock::Base` and implements the
+includes (or module that extends) `Circuitry::Locks::Base` and implements the
 following methods:
 
 * `lock`: Accepts the `key` and `ttl` as parameters.  If the key is already
@@ -339,12 +339,14 @@ following methods:
   processed more than once.
 * `lock!`: Accepts the `key` and `ttl` as parameters.  Must lock the key for
   `ttl` seconds regardless of whether or not the key was previously locked.
+* `unlock!`: Accepts the `key` as a parameter.  Must unlock (delete) the key if
+  it was previously locked.
 
 For example, a database-backed solution might look something like the following:
 
 ```ruby
 class DatabaseLockStrategy
-  include Circuitry::Lock::Base
+  include Circuitry::Locks::Base
 
   def initialize(options = {})
     super(options)
@@ -361,6 +363,10 @@ class DatabaseLockStrategy
     connection.exec("UPSERT INTO locks (key, expires_at) VALUES ('#{key}', '#{Time.now + ttl}')")
   end
 
+  def unlock!(key)
+    connection.exec("DELETE FROM locks WHERE key = '#{key}'")
+  end
+
   private
 
   attr_reader :connection

data/lib/circuitry/locks/base.rb

@@ -1,7 +1,7 @@
 module Circuitry
   module Locks
     module Base
-      DEFAULT_SOFT_TTL = (15 * 60).freeze       # 15 minutes
+      DEFAULT_SOFT_TTL = (5 * 60).freeze        # 5 minutes
       DEFAULT_HARD_TTL = (24 * 60 * 60).freeze  # 24 hours
 
       attr_reader :soft_ttl, :hard_ttl
@@ -19,6 +19,10 @@ module Circuitry
         lock!(lock_key(id), hard_ttl)
       end
 
+      def unlock(id)
+        unlock!(lock_key(id))
+      end
+
       protected
 
       def lock(key, ttl)
@@ -29,6 +33,10 @@ module Circuitry
         raise NotImplementedError
       end
 
+      def unlock!(key)
+        raise NotImplementedError
+      end
+
       private
 
       attr_writer :soft_ttl, :hard_ttl

data/lib/circuitry/locks/memcache.rb

@@ -22,6 +22,10 @@ module Circuitry
         client.set(key, (Time.now + ttl).to_i, ttl)
       end
 
+      def unlock!(key)
+        client.delete(key)
+      end
+
       private
 
       attr_accessor :client

data/lib/circuitry/locks/memory.rb

@@ -36,6 +36,12 @@ module Circuitry
         end
       end
 
+      def unlock!(key)
+        store do |store|
+          store.delete(key)
+        end
+      end
+
       private
 
       def store(&block)

data/lib/circuitry/locks/noop.rb

@@ -12,6 +12,10 @@ module Circuitry
       def lock!(key, ttl)
         # do nothing
       end
+
+      def unlock!(key)
+        # do nothing
+      end
     end
   end
 end

data/lib/circuitry/locks/redis.rb

@@ -22,6 +22,10 @@ module Circuitry
         client.set(key, (Time.now + ttl).to_i, ex: ttl)
       end
 
+      def unlock!(key)
+        client.del(key)
+      end
+
       private
 
       attr_accessor :client

data/lib/circuitry/subscriber.rb

@@ -116,6 +116,7 @@ module Circuitry
             block.call(message.body, message.topic.name)
           end
         rescue => e
+          lock.unlock(message.id)
           logger.error("Error handling message #{message.id}: #{e}")
           raise e
         end

data/lib/circuitry/version.rb

@@ -1,3 +1,3 @@
 module Circuitry
-  VERSION = '1.2.0'
+  VERSION = '1.2.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: circuitry
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Matt Huggins
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-07-20 00:00:00.000000000 Z
+date: 2015-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog-aws