lockistics 0.1.2 → 0.1.3

data/README.md

@@ -138,6 +138,34 @@ It works exactly like the above, but the method is `meterlock`.
   end
 ```
 
+#### Wrapping instance methods of a class
+
+This is still experimental and I'm not quite happy with the implementation.
+
+```ruby
+  class SomeClass
+    include Lockistics::Meterable
+    meter :some_instance_method
+    # or:
+    meter :all, :except => :not_this_method
+
+    def some_instance_method
+      do_something
+    end
+
+    def not_this_method
+      do_something
+    end
+  end
+```
+
+Now each call to `some_instance_method` should be wrapped inside a meter
+block and the key name is "someclass_some_instance_method".
+
+The include and meter commands should be placed above any method
+definitions in the file. Prettier implementation would be appreciated,
+preferably one that would work with class methods also.
+
 #### Getting the statistics out
 
 You can query statistics for locking/metering keys.

data/lib/lockistics/meterable.rb

@@ -0,0 +1,54 @@
+module Lockistics
+  module Meterable
+    def self.included(where)
+      where.extend ClassMethods
+    end
+
+    module ClassMethods
+      @@_metered_methods = {}
+      @@_meter_all = false
+
+      def meter_wrap(meth_name)
+        @@_metered_methods[meth_name][:method] = instance_method(meth_name)
+        define_method(meth_name) do |*args, &block|
+          Lockistics.meter("#{@@_metered_methods[meth_name][:options][:prefix]}_#{meth_name}") do
+            @@_metered_methods[meth_name][:method].bind(self).call *args, &block
+          end
+        end
+      end
+
+      def meter(*args)
+        if args.last.kind_of?(Hash)
+          options = args.pop
+        else
+          options = {}
+        end
+        options = {
+          :prefix => self.name.downcase
+        }.merge(options)
+
+        if args.first.eql?(:all)
+          @@_meter_all = true
+          @@_meter_all_options = {:except => []}.merge(options)
+        end
+
+        Array(args).each do |meth_name|
+          @@_metered_methods[meth_name] = {}
+          @@_metered_methods[meth_name][:options] = options
+        end
+      end
+
+      def method_added(meth_name)
+        super
+        if @@_metered_methods && @@_metered_methods[meth_name] && @@_metered_methods[meth_name][:method].nil?
+          meter_wrap meth_name
+        elsif @@_meter_all && !Array(@@_meter_all_options[:except]).include?(meth_name) && @@_metered_methods[meth_name].nil?
+          @@_metered_methods[meth_name] = {}
+          @@_metered_methods[meth_name][:options] = @@_meter_all_options
+          meter_wrap meth_name
+        end
+      end
+
+    end
+  end
+end

data/lib/lockistics/version.rb

@@ -1,3 +1,3 @@
 module Lockistics
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/lockistics.rb

@@ -3,6 +3,7 @@ require "lockistics/configuration"
 require "lockistics/lock"
 require "lockistics/meter"
 require "lockistics/statistics"
+require "lockistics/meterable"
 
 # Lockistics is basically a distributed mutex on Redis.
 #
@@ -19,6 +20,19 @@ require "lockistics/statistics"
 #  - Minimum and maximum duration
 #  - Minimum and maximum memory growth (using OS gem)
 #  - Arbitary metrics you add during execution
+#
+#  Theres also an experimental module you can use to wrap any instance
+#  methods inside a meter block.
+#
+#  @example
+#    class SomeClass
+#      include Lockistics::Meterable
+#      meter :instance_method_name
+#
+#      def instance_method_name
+#        do_something
+#      end
+#    end
 module Lockistics
 
   # Configure the gem

data/spec/meterable_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+class MeterableTest
+
+  include Lockistics::Meterable
+
+  meter :all, :except => [
+    :do_not_meter_this_instance_method,
+    :meter_this_instance_method_too
+  ]
+  meter :meter_this_instance_method_too
+
+  def self.meter_this_class
+    "ok_class"
+  end
+
+  def meter_this_instance_method
+    "ok"
+  end
+
+  def meter_this_instance_method_too
+    "ok"
+  end
+
+  def do_not_meter_this_instance_method
+    "ok"
+  end
+
+end
+
+describe "Lockistics.meterable" do
+  it "should wrap desired methods into meters" do
+    MeterableTest.new.meter_this_instance_method.should eq "ok"
+    last_total = Lockistics.redis.hgetall("lockistics.meterabletest_meter_this_instance_method.total")
+    last_total.should_not be_empty
+    MeterableTest.new.meter_this_instance_method_too.should eq "ok"
+    last_total = Lockistics.redis.hgetall("lockistics.meterabletest_meter_this_instance_method_too.total")
+    last_total.should_not be_empty
+    MeterableTest.new.do_not_meter_this_instance_method.should eq "ok"
+    last_total = Lockistics.redis.hgetall("lockistics.meterabletest_do_not_meter_this_instance_method.total")
+    last_total.should be_empty
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: lockistics
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 29
   prerelease: 
   segments: 
   - 0
   - 1
-  - 2
-  version: 0.1.2
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - Kimmo Lehto
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-05-20 00:00:00 Z
+date: 2014-06-03 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement 
@@ -122,11 +122,13 @@ files:
 - lib/lockistics/configuration.rb
 - lib/lockistics/lock.rb
 - lib/lockistics/meter.rb
+- lib/lockistics/meterable.rb
 - lib/lockistics/statistics.rb
 - lib/lockistics/version.rb
 - lockistics.gemspec
 - spec/locking_spec.rb
 - spec/meter_spec.rb
+- spec/meterable_spec.rb
 - spec/spec_helper.rb
 - spec/statistics_spec.rb
 homepage: https://github.com/kke/lockistics
@@ -165,5 +167,6 @@ summary: With lockistics you can use Redis to create distributed locks and colle
 test_files: 
 - spec/locking_spec.rb
 - spec/meter_spec.rb
+- spec/meterable_spec.rb
 - spec/spec_helper.rb
 - spec/statistics_spec.rb