lockistics 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lockistics.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org>

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Kimmo Lehto
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,170 @@
+# Lockistics
+
+Lockistics is basically a distributed mutex on Redis with statistics collecting included.
+
+The likely use case for locking would be something like a Raketask that you don't want running multiple instances at once.
+
+The likely use case for the statistics part would be that you want to how often something is being called or if a certain Raketask has been run today or not. You can also use it to find memory leaks or slow methods, kind of private NewRelic with zero features.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'lockistics'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lockistics
+
+#### Redis
+
+Notice that you need a Redis v2.6.2+ as this gem uses LUA for race condition safe lock acquiring and min/max setting
+
+## Usage
+
+You can use both parts separately if you just want to collect statistics or to just do simple locking.
+
+Total, daily and hourly metrics you get for each key are:
+
+ - Number of locks
+ - Number of times having to wait for lock
+ - Number of failed locking attempts
+ - Minimum and maximum duration
+ - Minimum and maximum memory growth (using OS gem)
+ - Arbitary metrics you add during execution (more on this in examples)
+
+## Why?
+
+Convenience mostly. There are redis-locking gems and some quite complex statistics modules, this does both with minimum dependencies, easy usage and Ruby 1.8.7 support.
+
+## Examples
+
+#### Configure the gem
+
+These are the default settings :
+
+```ruby
+  Lockistics.configure do |config|
+    config.redis                = Redis.new
+    config.namespace            = "lockistics"
+    config.expire               = 300  # seconds
+    config.sleep                = 0.5  # seconds to sleep between retries
+    config.retries              = 10   # retry times
+    config.raise                = true # raise Lockistics::TimeoutException when lock fails
+  end
+```
+
+#### Getting and using a lock
+
+```ruby
+  # Get a lock, do what you must, release lock. No statistics collection.
+  Lockistics.lock("generate-stuff-raketask") do
+    doing_some_heavy_stuff
+  end
+```
+
+```ruby
+  # Some raketask that you don't want to run multiple times at once :
+  namespace :raketask
+    desc 'Generate stuff'
+    task :generate_stuff do
+      return nil unless Lockistics.lock("generate-stuff", :wait => false)
+      ...
+    end
+  end
+```
+
+```ruby
+  # Handle exception when you fail to acquire a lock in time:
+  begin
+    Lockistics.lock("stuff") do
+      ...
+    end
+  rescue Lockistics::Timeout
+    ...
+  end
+```
+
+```ruby
+  # Don't raise exceptions
+  Lockistics.lock("stuff", :raise => false) do
+    ...
+  end
+```
+
+#### Statistics collection without locking
+
+It works exactly like the locking, but the method is `meter`.
+
+```ruby
+  # Perform something, statistics will be collected behind the scenes.
+  Lockistics.meter("generate-stuff-raketask") do
+    doing_some_stuff
+  end
+```
+
+```ruby
+  # Adding custom metrics
+  Lockistics.meter("generate-stuff") do |meter|
+    results = do_stuff
+    if results.empty?
+      meter.incr "empty_results"
+    else
+      meter.incrby "stuffs_done", results.size
+    end
+  end
+```
+
+#### Statistics collection with locking
+
+It works exactly like the above, but the method is `meterlock`.
+
+```ruby
+  # Adding custom metrics
+  Lockistics.meterlock("generate-stuff", :raise => false) do |meter|
+    results = do_stuff
+    if results.empty?
+      meter.incr "empty_results"
+    else
+      # Sets min and/or max for a key (min.stuffs_done + max.stuffs_done)
+      # Only sets if value is minimum or maximum for the periods.
+      meter.set_minmax "stuffs_done", results.size
+    end
+  end
+```
+
+#### Getting the statistics out
+
+You can query statistics for locking/metering keys.
+
+```ruby
+  stats = Lockistics.statistics('generate'stuff')
+  # Get the last run
+  stats.last_run
+   => Mon May 19 16:38:52 +0300 2014
+  # Get totals:
+  stats.total
+   => {"invocations" => 50, "lock-timeouts" => 1,
+       "max.stuffs-generated" => 10, "max_rss" => 400 ..}
+  stats.daily
+   => [{:time => #<Time..> "invocations" => 50, "lock-timeouts" => 1,
+       "max.stuffs-generated" => 10, "max_rss" => 400 ..}, {..}]
+  stats.hourly
+   => [{:time => #<Time..> "invocations" => 50, "lock-timeouts" => 1,
+       "max.stuffs-generated" => 10, "max_rss" => 400 ..}, {..}]
+  stats.all
+   => { :daily => [...], :hourly => [...], :total => {...},
+        :last_run:time => #<Time..>}
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)

data/lib/lockistics/configuration.rb

@@ -0,0 +1,34 @@
+require 'redis'
+
+module Lockistics
+  class Configuration
+
+    attr_accessor :redis
+    attr_accessor :namespace
+    attr_accessor :logger
+    attr_accessor :expire
+    attr_accessor :sleep
+    attr_accessor :retries
+    attr_accessor :raise
+
+    def initialize
+      @redis     = Redis.new
+      @namespace = 'lockistics'
+      @expire    = 10
+      @sleep     = 0.5
+      @retries   = 10
+    end
+
+    def lock_defaults
+      {
+        :redis => redis,
+        :namespace => namespace,
+        :expire => expire,
+        :sleep => sleep,
+        :retries => retries,
+        :wait => true,
+        :raise => true
+      }
+    end
+  end
+end

data/lib/lockistics/lock.rb

@@ -0,0 +1,67 @@
+module Lockistics
+
+  class LockTimeout < StandardError; end
+
+  class Lock
+
+    attr_accessor :key, :options, :lock_retries
+
+    LUA_ACQUIRE = "return redis.call('setnx', KEYS[1], 1) == 1 and redis.call('expire', KEYS[1], KEYS[2]) and 1 or 0"
+
+    def initialize(key, options={})
+      @key     = key
+      @options = Lockistics.configuration.lock_defaults.merge(options)
+      @options[:expire] = 999_999_999 unless @options[:expire].to_i > 0 # :expire => false
+      @exceeded_before_release = false
+      @lock_retries = 0
+    end
+
+    def acquire_lock
+      Lockistics.known_keys(key)
+      if got_lock?
+        true
+      elsif options[:wait]
+        wait_for_lock
+      else
+        false
+      end
+    end
+
+    def wait_for_lock
+      until got_lock?
+        @lock_retries += 1
+        if lock_retries <= options[:retries]
+          sleep options[:sleep]
+        elsif options[:raise]
+          raise LockTimeout, "while waiting for #{key}"
+        else
+          return false
+        end
+      end
+      true
+    end
+
+    def exceeded_before_release?
+      @exceeded_before_release
+    end
+
+    def release_lock
+      @exceeded_before_release = redis.del(namespaced_key) == 0
+    end
+
+    def namespaced_key
+      @namespaced_key ||= "#{Lockistics.configuration.namespace}.lock.#{key}"
+    end
+
+    private
+
+    def redis
+      Lockistics.redis
+    end
+
+    def got_lock?
+      redis.eval(LUA_ACQUIRE, [namespaced_key, options[:expire]]) == 1
+    end
+
+  end
+end

data/lib/lockistics/meter.rb

@@ -0,0 +1,165 @@
+require 'os'
+
+module Lockistics
+  class Meter
+
+    attr_accessor :key, :options
+
+    LUA_SETMAX = <<-EOB.gsub("\n", " ").gsub(/\s+/, " ")
+      if redis.call("hexists", KEYS[1], KEYS[2]) == 0 or
+         tonumber(redis.call("hget", KEYS[1], KEYS[2])) < tonumber(ARGV[1])
+      then
+        return redis.call("hset", KEYS[1], KEYS[2], ARGV[1])
+      else
+        return 0
+      end
+    EOB
+
+    LUA_SETMIN = <<-EOB.gsub("\n", " ").gsub(/\s+/, " ")
+      if redis.call("hexists", KEYS[1], KEYS[2]) == 0 or
+         tonumber(redis.call("hget", KEYS[1], KEYS[2])) > tonumber(ARGV[1])
+      then
+        return redis.call("hset", KEYS[1], KEYS[2], ARGV[1])
+      else
+        return 0
+      end
+    EOB
+
+    def initialize(key, options={})
+      @key     = key
+      @options = options
+      @lock_timeouts = 0
+    end
+
+    def with_lock(&block)
+      raise ArgumentError, "with_lock called without block" unless block_given?
+      raise ArgumentError, "lock not defined" if lock.nil?
+      lock.acquire_lock
+      yield self
+    ensure
+      lock.release_lock
+    end
+
+    def perform(&block)
+      raise ArgumentError, "perform called without block" unless block_given?
+      before_perform
+      lock.nil? ? yield(self) : with_lock(&block)
+    rescue Lockistics::LockTimeout
+      @lock_timeouts = 1
+      raise
+    ensure
+      after_perform
+    end
+
+    # You can add custom metrics during runtime
+    #
+    # @example
+    #   Lockistics.meter do |meter|
+    #     foo = FooGenerator.new
+    #     foo.perform
+    #     meter.incrby 'foos-generated', foo.count
+    #   end
+    def incrby(key, value)
+      return nil if value == 0
+      [:hourly, :daily, :total].each do |period|
+        redis.hincrby namespaced_hash(period), key, value
+      end
+    end
+
+    # You can add custom metrics during runtime with
+    # this.
+    #
+    # This is a shortcut to incrby(key, 1)
+    #
+    # @example
+    #   Lockistics.meter do |meter|
+    #     foo = FooGenerator.new
+    #     foo.perform
+    #     meter.incr 'failed-foo-generations' unless foo.success?
+    #   end
+    def incr(key)
+      incrby(key, 1)
+    end
+
+    def set_minmax(key, value)
+      [:hourly, :daily, :total].each do |period|
+        redis_hsetmax(namespaced_hash(period), "max.#{key}", value)
+        redis_hsetmin(namespaced_hash(period), "min.#{key}", value)
+      end
+    end
+
+    private
+
+    def redis
+      Lockistics.configuration.redis
+    end
+
+    def redis_hsetmax(hash, key, value)
+      redis.eval(LUA_SETMAX, [hash, key], [value]) == 1
+    end
+
+    def redis_hsetmin(hash, key, value)
+      redis.eval(LUA_SETMIN, [hash, key], [value]) == 1
+    end
+
+    def lock
+      options[:lock]
+    end
+
+    def before_perform
+      Lockistics.known_keys(key)
+      @start_time = Time.now.to_f
+      @start_rss  = OS.rss_bytes
+      redis.pipelined do
+        redis.sadd "#{Lockistics.configuration.namespace}.#{key}.hourlies", hourly_timestamp
+        redis.sadd "#{Lockistics.configuration.namespace}.#{key}.dailies",  daily_timestamp
+        redis.set  "#{Lockistics.configuration.namespace}.#{key}.last_run", Time.now.to_i
+      end
+    end
+
+    def after_perform
+      unless @lock_timeouts > 0
+        @duration     = ((Time.now.to_f - @start_time) * 1000).round
+        @rss_increase = ((OS.rss_bytes  - @start_rss)  / 1024).round
+      end
+      add_meter_statistics unless options[:no_metrics]
+      add_lock_statistics  unless lock.nil?
+    end
+
+    def add_meter_statistics
+      incrby 'invocations', 1
+      set_minmax 'rss',  @rss_increase unless @rss_increase.nil?
+      set_minmax 'time', @duration     unless @duration.nil?
+    end
+
+    def add_lock_statistics
+      redis.pipelined do
+        incrby 'lock-invocations', 1
+        incrby 'lock-retries', lock.lock_retries
+        incrby 'lock-timeouts', @lock_timeouts
+        if lock.exceeded_before_release?
+          incrby 'lock-exceeded-before-release', 1
+        end
+      end
+    end
+
+    def hourly_timestamp
+      @hourly_timestamp ||= Time.now.strftime("%Y%m%d%H")
+    end
+
+    def daily_timestamp
+      @daily_timestamp ||= Time.now.strftime("%Y%m%d")
+    end
+
+    def namespaced_hash(period)
+      case period
+      when :hourly
+        "#{Lockistics.configuration.namespace}.#{key}.hourly.#{hourly_timestamp}"
+      when :daily
+        "#{Lockistics.configuration.namespace}.#{key}.daily.#{daily_timestamp}"
+      when :total
+        "#{Lockistics.configuration.namespace}.#{key}.total"
+      end
+    end
+  end
+end

data/lib/lockistics/statistics.rb

@@ -0,0 +1,89 @@
+require 'time'
+module Lockistics
+  class Statistics
+
+    attr_accessor :key
+
+    def initialize(key)
+      @key = key
+    end
+
+    def last_run
+      unix_time = redis.get(namespaced("#{key}.last_run"))
+      if unix_time
+        Time.at(unix_time.to_i)
+      end
+    end
+
+    def all(since=nil)
+      {
+        :daily => daily(since),
+        :hourly => hourly(since),
+        :total => total,
+        :last_run => last_run
+      }
+    end
+
+    def daily(since=nil)
+      daily_hashes(since).collect{|stamped| redis.hgetall(stamped.first).merge(:time => stamped.last )}
+    end
+
+    def hourly(since=nil)
+      hourly_hashes(since).collect{|stamped| redis.hgetall(stamped.first).merge(:time => stamped.last)}
+    end
+
+    def total
+      redis.hgetall total_hash
+    end
+
+    private
+
+    def date_to_hourly_stamp(date=nil)
+      if date.nil?
+        0
+      elsif date.respond_to?(strftime)
+        date.strftime("%Y%m%d%H")
+      elsif date.match(/^\d+$/)
+        Time.at(date).strftime("%Y%m%d%H")
+      end
+    end
+
+    def date_to_daily_stamp(date=nil)
+      if date.nil?
+        0
+      elsif date.respond_to?(strftime)
+        date.strftime("%Y%m%d")
+      elsif date.match(/^\d+$/)
+        Time.at(date).strftime("%Y%m%d")
+      end
+    end
+
+    def redis
+      Lockistics.redis
+    end
+
+    def daily_hashes(since=nil)
+      stamped_ts = date_to_daily_stamp(since)
+      redis.smembers(namespaced("#{key}.dailies")).collect do |ts|
+        next if ts.to_i < stamped_ts
+        [namespaced("#{key}.daily.#{ts}"), Time.parse(ts)]
+      end
+    end
+
+    def hourly_hashes(since=nil)
+      stamped_ts = date_to_hourly_stamp(since)
+      redis.smembers(namespaced("#{key}.hourlies")).collect do |ts|
+        next if ts.to_i < stamped_ts
+        [namespaced("#{key}.hourly.#{ts}"), Time.parse(ts)]
+      end
+    end
+
+    def total_hash
+      namespaced "#{key}.total"
+    end
+
+    def namespaced(extra_key=nil)
+      "#{Lockistics.configuration.namespace}#{extra_key.nil? ? "" : ".#{extra_key}"}"
+    end
+  end
+end

data/lib/lockistics/version.rb

@@ -0,0 +1,3 @@
+module Lockistics
+  VERSION = "0.1.0"
+end

data/lib/lockistics.rb

@@ -0,0 +1,137 @@
+require "lockistics/version"
+require "lockistics/configuration"
+require "lockistics/lock"
+require "lockistics/meter"
+require "lockistics/statistics"
+
+# Lockistics is basically a distributed mutex on Redis.
+#
+# In addition to locking it also collects statistics data
+# of the locking events.
+#
+# You can use each part separately if you just want to
+# collect statistics or to do simple locking.
+#
+# Total, daily and hourly metrics you get for each key are:
+#  - Number of locks
+#  - Number of times having to wait for lock
+#  - Number of failed locking attempts
+#  - Minimum and maximum duration
+#  - Minimum and maximum memory growth (using OS gem)
+#  - Arbitary metrics you add during execution
+module Lockistics
+
+  # Configure the gem
+  #
+  # @example
+  #   Lockistics.configure do |config|
+  #     config.redis                = Redis.new
+  #     config.namespace            = "production.locks"
+  #     config.expire               = 300  # seconds
+  #     config.sleep                = 0.5  # seconds to sleep between retries
+  #     config.retries              = 10   # retry times
+  #     config.raise                = true # raise Lockistics::TimeoutException when lock fails
+  #   end
+  def self.configure(&block)
+    yield configuration
+  end
+
+  # Returns an instance of Lockistics::Configuration
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # Accessor to the redis configured via Lockistics::Configuration
+  def self.redis
+    configuration.redis
+  end
+
+  # Get a hold of a lock or wait for it to be released
+  #
+  # Given a block, will release the lock after block exection
+  #
+  # @example
+  #   Lockistics.lock("generate-stuff-raketask") do
+  #     doing_some_heavy_stuff
+  #   end
+  #   or
+  #   return nil unless Lockistics.lock("generate-stuff", :wait => false)
+  #   or
+  #   begin
+  #     Lockistics.lock("stuff") do
+  #       ...
+  #     end
+  #   rescue Lockistics::Timeout
+  #     ...
+  #   end
+  def self.lock(key, options={}, &block)
+    if block_given?
+      Meter.new(key, options.merge(:no_metrics => true)).perform(&block)
+    else
+      Lock.new(key, options).acquire_lock
+    end
+  end
+
+  # Don't perform locking, just collect metrics.
+  #
+  # @example
+  #   Lockistics.meter("generate-stuff") do |meter|
+  #     do_stuff
+  #     meter.incrby :stuffs_generated, 50
+  #   end
+  def self.meter(key, options={}, &block)
+    Meter.new(key, options.merge(:lock => nil)).perform(&block)
+  end
+
+  # Perform locking and statistics collection
+  #
+  # @example
+  #   Lockistics.meterlock("generate-stuff") do |meter|
+  #     results = do_stuff
+  #     if results.empty?
+  #       meter.incr "empty_results"
+  #     else
+  #       meter.incrby "stuffs_done", results.size
+  #     end
+  #   end
+  def self.meterlock(key, options={}, &block)
+    Meter.new(key, options.merge(:lock => Lock.new(key, options))).perform(&block)
+  end
+
+  # Manually release a lock
+  #
+  # @example
+  #   Lockistics.release("generate-stuff")
+  #   or
+  #   lock = Lockistics.lock("generate-stuff", :wait => false)
+  #   if lock.acquire_lock
+  #     do_some_stuff
+  #     lock.release_lock
+  #   end
+  def self.release(key, options={})
+    Lock.new(key).release_lock
+  end
+
+  # Returns an instance of Lockistics::Statistics for the key.
+  #
+  # @example
+  #   stats = Lockistics.statistics('generate-stuff')
+  #   stats.last_run
+  #     => Mon May 19 16:38:52 +0300 2014
+  #   stats.total
+  #     => {"invocations" => 50, ...}
+  def self.statistics(key)
+    Statistics.new(key)
+  end
+
+  # Get a list of known keys or add a key to
+  # known keys list.
+  def self.known_keys(key=nil)
+    if key.nil?
+      redis.smembers "#{Lockistics.configuration.namespace}.known_keys"
+    else
+      redis.sadd "#{Lockistics.configuration.namespace}.known_keys", key
+    end
+  end
+
+end

data/lockistics.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lockistics/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lockistics"
+  spec.version       = Lockistics::VERSION
+  spec.authors       = ["Kimmo Lehto"]
+  spec.email         = ["kimmo.lehto@gmail.com"]
+  spec.description   = %q{Statsistics collecting locking}
+  spec.summary       = %q{With lockistics you can use Redis to create distributed locks and collect statistics how often and how long your locks are held}
+  spec.homepage      = "https://github.com/kke/lockistics"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "redis"
+  spec.add_runtime_dependency "os"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "fakeredis"
+end

data/spec/locking_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe "Lockistics.lock" do
+  it "should only allow one instance to lock something at once" do
+    lock1 = Lockistics.lock("ltest1", :wait => false, :raise => false, :expire => 100)
+    sleep 1
+    lock2 = Lockistics.lock("ltest1", :wait => false, :raise => false, :expire => 100)
+    lock1.should be_true
+    lock2.should be_false
+    Lockistics.release("ltest1")
+    lock2 = Lockistics.lock("ltest1", :wait => false, :raise => false, :expire => 100)
+    lock2.should be_true
+  end
+
+  it "should allow locking again after block mode" do
+    lock1_ok = false
+    lock2_ok = false
+    lock1 = Lockistics.lock("ltest1", :wait => false, :raise => false, :expire => 100) do
+      lock1_ok = true
+      sleep 1
+    end
+    lock2 = Lockistics.lock("ltest1", :wait => false, :raise => false, :expire => 100) do
+      lock2_ok = true
+    end
+    lock1_ok.should be_true
+    lock2_ok.should be_true
+    Lockistics.release("ltest1")
+  end
+
+  it "should allow locking different keys at once" do
+    lock1_ok = false
+    lock2_ok = false
+    lock1 = Lockistics.lock("ltest1", :wait => false, :raise => false, :expire => 100) do
+      lock1_ok = true
+      lock2 = Lockistics.lock("ltest2", :wait => false, :raise => false, :expire => 100) do
+        lock2_ok = true
+      end
+    end
+    lock1_ok.should be_true
+    lock2_ok.should be_true
+    Lockistics.release("ltest1")
+    Lockistics.release("ltest2")
+  end
+
+  it "should raise when lock not acquired" do
+    lock1_ok = false
+    lock2_ok = false
+    lock1 = Lockistics.lock("ltest1", :wait => false, :raise => false, :expire => 100)
+    expect {Lockistics.lock("ltest1")}.to raise_error(Lockistics::LockTimeout)
+    Lockistics.release("ltest1")
+    Lockistics.release("ltest2")
+  end
+end

data/spec/meter_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe "Lockistics.meter" do
+  it "should collect daily metrics" do
+    Lockistics.meter("mtest1") do
+      sleep 1
+    end
+    last_daily_ts = Lockistics.redis.smembers("lockistics.mtest1.dailies").last
+    last_daily_ts.should_not be_nil
+    last_daily = Lockistics.redis.hgetall("lockistics.mtest1.daily.#{last_daily_ts}")
+    last_daily.should be_a Hash
+    last_daily["max.time"].to_i.should be > 1000
+    last_max_time = last_daily["max.time"].to_i
+    last_daily["invocations"].to_i.should eq 1
+    Lockistics.meter("mtest1") do
+      sleep 3
+    end
+    last_daily_ts = Lockistics.redis.smembers("lockistics.mtest1.dailies").last
+    last_daily_ts.should_not be_nil
+    last_daily = Lockistics.redis.hgetall("lockistics.mtest1.daily.#{last_daily_ts}")
+    last_daily.should be_a Hash
+    last_daily["max.time"].to_i.should be > 2000
+    last_daily["min.time"].to_i.should eq last_max_time
+    last_daily["invocations"].to_i.should eq 2
+    Lockistics.redis.del("lockistics.mtest1.daily.#{last_daily_ts}")
+  end
+
+  it "should collect hourly metrics" do
+    Lockistics.meter("mtest2") do
+      sleep 1
+    end
+    last_hourly_ts = Lockistics.redis.smembers("lockistics.mtest2.hourlies").last
+    last_hourly_ts.should_not be_nil
+    last_hourly = Lockistics.redis.hgetall("lockistics.mtest2.hourly.#{last_hourly_ts}")
+    last_hourly.should be_a Hash
+    last_hourly["max.time"].to_i.should be > 1000
+    last_max_time = last_hourly["max.time"].to_i
+    last_hourly["invocations"].to_i.should eq 1
+    Lockistics.meter("mtest2") do
+      sleep 3
+    end
+    last_hourly_ts = Lockistics.redis.smembers("lockistics.mtest2.hourlies").last
+    last_hourly_ts.should_not be_nil
+    last_hourly = Lockistics.redis.hgetall("lockistics.mtest2.hourly.#{last_hourly_ts}")
+    last_hourly.should be_a Hash
+    last_hourly["max.time"].to_i.should be > 2000
+    last_hourly["min.time"].to_i.should eq last_max_time
+    last_hourly["invocations"].to_i.should eq 2
+    Lockistics.redis.del("lockistics.mtest2.hourly.#{last_hourly_ts}")
+  end
+
+  it "should collect total metrics" do
+    Lockistics.meter("mtest3") do
+      sleep 1
+    end
+    last_total = Lockistics.redis.hgetall("lockistics.mtest3.total")
+    last_total.should be_a Hash
+    last_invocations = last_total["invocations"].to_i
+    Lockistics.meter("mtest3") do
+      sleep 3
+    end
+    last_total = Lockistics.redis.hgetall("lockistics.mtest3.total")
+    last_total["invocations"].to_i.should eq last_invocations + 1
+    Lockistics.redis.del("lockistics.mtest3.total")
+  end
+
+  it "should collect custom metrics" do
+    Lockistics.meter("mtest4") do |meter|
+      meter.incr "stuffs_done"
+      meter.incrby "stuffs_done2", 5
+      meter.set_minmax "stuffs_done3", 10
+    end
+    last_hourly_ts = Lockistics.redis.smembers("lockistics.mtest4.hourlies").last
+    last_hourly    = Lockistics.redis.hgetall("lockistics.mtest4.hourly.#{last_hourly_ts}")
+    last_hourly["min.stuffs_done3"].to_i.should eq 10
+    last_hourly["max.stuffs_done3"].to_i.should eq 10
+    last_hourly["stuffs_done2"].to_i.should eq 5
+    last_hourly["stuffs_done"].to_i.should eq 1
+    Lockistics.meter("mtest4") do |meter|
+      meter.incr "stuffs_done"
+      meter.incrby "stuffs_done2", 5
+      meter.set_minmax "stuffs_done3", 20
+    end
+    last_hourly_ts = Lockistics.redis.smembers("lockistics.mtest4.hourlies").last
+    last_hourly    = Lockistics.redis.hgetall("lockistics.mtest4.hourly.#{last_hourly_ts}")
+    last_hourly["min.stuffs_done3"].to_i.should eq 10
+    last_hourly["max.stuffs_done3"].to_i.should eq 20
+    last_hourly["stuffs_done2"].to_i.should eq 10
+    last_hourly["stuffs_done"].to_i.should eq 2
+  end
+
+  it "should collect metrics while locking too" do
+    Lockistics.meterlock("mtest4") do
+      sleep 1
+    end
+    last_hourly_ts = Lockistics.redis.smembers("lockistics.mtest4.dailies").last
+    last_hourly    = Lockistics.redis.hgetall("lockistics.mtest4.dailies.#{last_hourly_ts}")
+  end
+
+  it "should know known keys" do
+    Lockistics.redis.del("lockistics.known_keys")
+    Lockistics.lock("mtest1", :wait => false, :raise => false) {}
+    Lockistics.meter("mtest2") {}
+    Lockistics.meterlock("mtest3", :wait => false, :raise => false) {}
+    Lockistics.known_keys.include?("mtest1").should be_true
+    Lockistics.known_keys.include?("mtest2").should be_true
+    Lockistics.known_keys.include?("mtest3").should be_true
+    Lockistics.known_keys.include?("mtest4").should be_false
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,56 @@
+require 'rspec'
+require 'redis'
+require 'fakeredis'
+require File.expand_path('../../lib/lockistics.rb', __FILE__)
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end
+
+class Redis
+  def eval(script, keys=[], args=[])
+    case script
+    when Lockistics::Lock::LUA_ACQUIRE
+      fake_acquire(keys, args)
+    when Lockistics::Meter::LUA_SETMAX
+      fake_hsetmax(keys, args)
+    when Lockistics::Meter::LUA_SETMIN
+      fake_hsetmin(keys, args)
+    else
+      super
+    end
+  end
+
+  def fake_acquire(keys, args=[])
+    return false if existing = get(keys.first)
+    if setnx(keys.first, 1)
+      expire keys.first, keys.last
+      1
+    else
+      0
+    end
+  end
+
+  def fake_hsetmax(keys=[], args=[])
+    existing = hget(keys[0], keys[1])
+    if existing.nil? || args.first > existing.to_i
+      hset(keys[0], keys[1], args.first)
+      1
+    else
+      0
+    end
+  end
+
+  def fake_hsetmin(keys=[], args=[])
+    existing = hget(keys[0], keys[1])
+    if existing.nil? || args.first < existing.to_i
+      hset(keys[0], keys[1], args.first)
+      1
+    else
+      0
+    end
+  end
+end

data/spec/statistics_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe "Lockistics.statistics" do
+  it "should get total metrics" do
+    Lockistics.meter("stest1") do
+      sleep 1
+    end
+    stats = Lockistics.statistics("stest1")
+    stats.total["max.time"].to_i.should be > 1000
+    stats.total["invocations"].to_i.should eq 1
+    Lockistics.meter("stest1") do
+      sleep 3
+    end
+    stats = Lockistics.statistics("stest1")
+    stats.total["max.time"].to_i.should be > 3000
+    stats.total["invocations"].to_i.should eq 2
+  end
+
+  it "should get daily metrics" do
+    Lockistics.meter("stest2") do
+      sleep 1
+    end
+    stats = Lockistics.statistics("stest2")
+    stats.daily.should be_a Array
+    stats.daily.first[:time].should be_a Time
+  end
+
+  it "should get hourly metrics" do
+    Lockistics.meter("stest3") do
+      sleep 1
+    end
+    stats = Lockistics.statistics("stest3")
+    stats.hourly.should be_a Array
+    stats.hourly.first[:time].should be_a Time
+  end
+end
+

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification 
+name: lockistics
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Kimmo Lehto
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-05-19 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: redis
+  prerelease: false
+  type: :runtime
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: os
+  prerelease: false
+  type: :runtime
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  name: bundler
+  prerelease: false
+  type: :development
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rake
+  prerelease: false
+  type: :development
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rspec
+  prerelease: false
+  type: :development
+  requirement: *id005
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: fakeredis
+  prerelease: false
+  type: :development
+  requirement: *id006
+description: Statsistics collecting locking
+email: 
+- kimmo.lehto@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/lockistics.rb
+- lib/lockistics/configuration.rb
+- lib/lockistics/lock.rb
+- lib/lockistics/meter.rb
+- lib/lockistics/statistics.rb
+- lib/lockistics/version.rb
+- lockistics.gemspec
+- spec/locking_spec.rb
+- spec/meter_spec.rb
+- spec/spec_helper.rb
+- spec/statistics_spec.rb
+homepage: https://github.com/kke/lockistics
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: With lockistics you can use Redis to create distributed locks and collect statistics how often and how long your locks are held
+test_files: 
+- spec/locking_spec.rb
+- spec/meter_spec.rb
+- spec/spec_helper.rb
+- spec/statistics_spec.rb