visit-counter-omri 0.1.1

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 visit-counter.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Tom Caspy
+
+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,70 @@
+# VisitCounter
+
+[![Build Status](https://secure.travis-ci.org/KensoDev/visit-counter.png)](https://secure.travis-ci.org/KensoDev/visit-counter)
+
+VisitCounter is a gem which solves the annoying problem of counting visits and displaying them in real time. In an SQL database, for a site with a lot of hits, this can cause quite a lot of overhead. VisitCounter aims to solve this by using a quick key-value store to keep a delta, and only persist to the SQL DB when the delta crosses a certain percent of the saved counter.
+It can be used transparently, by overriding the accessor to the counter, or simply by using the helper functions it defines - incr_counter, read_counter, get_counter_delta and nullify_counter.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'visit-counter'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install visit-counter
+
+## Usage
+
+a. the default storage engine is redis. If you have a global $redis for your redis connection, we default to using that. Otherwise, or if you want to specify a different connection, in an initializer you should define it by:
+
+    VisitCounter::Store::RedisStore.redis = Redis.new(host: "your_redis_host", port: port)
+
+b. in the class you wish to have a visit counter simply declare
+    include VisitCounter
+from this moment on, you can use the incr_counter(:counter_name), nullify_counter(:counter_name) and read_counter(:counter_name) methods
+You can also do something like this:
+
+    class Foo < ActiveRecord::Base
+       include VisitCounter
+       cached_counter :counter_name
+    end
+
+this will override the counter_name method to read the live counter (from both database and the NoSQL storage) and add a increase_counter_name method for upping the counter by 1 (in the NoSQL and/or persist to DB when needed)
+
+##Thresholds
+
+the default behaviour of visit counter is that once the visits pass 30% of the staged number, the visit counter stages the changes and nullifies the delta. You can, however, tweak that method. including VisitCounter in a class creates two class attribute_accessors, one named visit_counter_threshold_method, the other visit_counter_threshold.
+visit_counter_threshold_method accepts either :static or :percent (the default), the threshold is either the decimal percent (0.1 for 10%) or an integer for :static. in case of the :static method you will percist to the DB once every (threshold) times the counter goes up.
+
+so you might want to do something like that:
+
+    class Foo < ActiveRecord::Base
+       include VisitCounter
+       cached_counter :counter_name
+       self.visit_counter_threshold_method = :static
+       self.visit_counter_threshold = 100
+    end
+
+if you want the counter to persist to database once every 100 views.
+
+if you need to run callbacks for whatever reason after you update the counter just:
+  
+  class Foo < ActiveRecord::Base
+    include VisitCounter
+    cached_counter :counter_name
+    self.update_callback_method = :update_something
+  end   
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec

data/lib/visit-counter.rb

@@ -0,0 +1,7 @@
+require "visit-counter/version"
+require "visit-counter/key"
+require "visit-counter/visit_counter"
+require "visit-counter/store/abstract_store"
+require "visit-counter/store/redis_store"
+require "visit-counter/store/rails_store"
+require "visit-counter/store"

data/lib/visit-counter/key.rb

@@ -0,0 +1,7 @@
+module VisitCounter
+  class Key
+    def self.key(object, method)
+      "visit_counter::#{object.class.to_s}::#{object.id}::#{method}"
+    end
+  end
+end

data/lib/visit-counter/store.rb

@@ -0,0 +1,18 @@
+module VisitCounter
+  class Store
+    @@engine ||= VisitCounter::Store::RedisStore
+
+    class << self
+
+      def set_engine(store)
+        @@engine = store
+      end
+
+      def engine
+        @@engine
+      end
+
+    end
+    
+  end
+end

data/lib/visit-counter/store/abstract_store.rb

@@ -0,0 +1,21 @@
+module VisitCounter
+  class Store
+    class AbstractStore
+      class << self
+        #placeholders
+
+        def incr(key)
+          raise NotImplementedError
+        end
+
+        def get(key)
+          raise NotImplementedError
+        end
+
+        def nullify(key)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/visit-counter/store/rails_store.rb

@@ -0,0 +1,6 @@
+module VisitCounter
+  class Store
+    class RailsStore < VisitCounter::Store::AbstractStore
+    end
+  end
+end

data/lib/visit-counter/store/redis_store.rb

@@ -0,0 +1,66 @@
+require "redis"
+
+module VisitCounter
+  class Store
+    class RedisStore < VisitCounter::Store::AbstractStore
+      @@redis = nil
+      class << self
+
+        def redis=(r)
+          if r.is_a?(Redis)
+            @@redis = r
+          else
+            @@redis = Redis.new(r)
+          end
+        end
+
+        def redis
+          if @@redis.nil? && defined?($redis)
+            @@redis = $redis
+          else
+            @@redis
+          end
+        end
+
+        def incr(key)
+          redis.incr(key).to_i
+        end
+
+        def get(key)
+          redis.get(key).to_i
+        end
+
+        def nullify(key)
+          redis.set(key, 0)
+        end
+
+        def substract(key, by)
+          redis.decrby(key, by)
+        end
+
+        def acquire_lock(object)
+          redis.setnx(lock_key(object), 1)
+        end
+
+        def unlock!(object)
+          redis.del(lock_key(object))
+        end
+
+        def lock_key(object)
+          "#{object.class.name.downcase}_#{object.id}_object_cache_lock"
+        end
+
+        def with_lock(object, &block)
+          if acquire_lock(object)
+            begin
+              yield
+            ensure
+              unlock!(object)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/visit-counter/version.rb

@@ -0,0 +1,3 @@
+module VisitCounter
+  VERSION = "0.1.1"
+end

data/lib/visit-counter/visit_counter.rb

@@ -0,0 +1,94 @@
+module VisitCounter
+
+  def self.included(base)
+    base.class_eval do
+      class << self
+        #defining class instance attributes
+        attr_accessor :visit_counter_threshold, :visit_counter_threshold_method, :update_callback_method
+      end
+    end
+    base.send(:include, InstanceMethods)
+    base.send(:extend, ClassMethods)
+  end
+
+  module InstanceMethods
+    def incr_counter(name)
+      key = VisitCounter::Key.key(self, name)
+      count = VisitCounter::Store.engine.incr(key)
+      staged_count = self.send(:read_attribute, name).to_i
+      if Helper.passed_limit?(self, staged_count, count, name)
+        Helper.persist(self, staged_count, count, name)
+      end
+    end
+
+    def get_counter_delta(name)
+      key = VisitCounter::Key.key(self, name)
+      VisitCounter::Store.engine.get(key)
+    end
+
+    def read_counter(name)
+      current_count = self.send(:read_attribute, name).to_i
+      count = get_counter_delta(name)
+
+      current_count + count
+    end
+
+    def nullify_counter_cache(name, substract = nil)
+      key = VisitCounter::Key.key(self, name)
+      if substract
+        VisitCounter::Store.engine.substract(key, substract)
+      else
+        VisitCounter::Store.engine.nullify(key)
+      end
+    end
+  end
+
+  module ClassMethods
+
+    def cached_counter(name)
+
+      self.send(:define_method, name) do
+        read_counter(name)
+      end
+
+      self.send(:define_method, "increase_#{name}") do
+        incr_counter(name)
+      end
+    end
+  end
+
+  class Helper
+    class << self
+      def passed_limit?(object, staged_count, diff, name)
+        method = object.class.visit_counter_threshold_method || :percent
+        threshold = object.class.visit_counter_threshold || default_threshold(method)
+
+        if method.to_sym == :static
+          diff >= threshold
+        elsif method.to_sym == :percent
+          return true if staged_count.to_i == 0
+          diff.to_f / staged_count.to_f >= threshold
+        end
+      end
+
+      def persist(object, staged_count, diff, name)
+        VisitCounter::Store.engine.with_lock(object) do
+          object.update_attribute(name, staged_count + diff)
+          if object.class.update_callback_method
+            object.send(object.class.update_callback_method)
+          end
+          object.nullify_counter_cache(name, diff)
+        end
+      end
+
+      def default_threshold(method)
+        if method.to_sym == :static
+          10
+        elsif method.to_sym == :percent
+          0.3
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/store_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe VisitCounter::Store do
+  
+  describe "engine" do
+    it "should have the redis store by default" do
+      VisitCounter::Store.engine.should == VisitCounter::Store::RedisStore
+    end
+
+    it "should be able to change the storage engine" do
+      VisitCounter::Store.set_engine(VisitCounter::Store::RailsStore)
+      VisitCounter::Store.engine.should == VisitCounter::Store::RailsStore
+
+      #switching back
+      VisitCounter::Store.set_engine(VisitCounter::Store::RedisStore)
+    end
+  end
+
+end

data/spec/lib/visit_counter_spec.rb

@@ -0,0 +1,175 @@
+require "spec_helper"
+
+class DummyObject
+  include VisitCounter
+
+  attr_accessor :counter, :update_callback_method
+
+  def update_attribute(attribute, value)
+    self.send("#{attribute}=", value)
+  end
+
+  def update_something
+    nil
+  end  
+
+  def read_attribute(name)
+    #yeah, evals are evil, but it works and it's for testing purposes only. we assume read_attribute is defined the same as in AR wherever we include this module
+    eval("@#{name}")
+  end
+end
+
+VisitCounter::Store::RedisStore.redis = Redis.new(host: "localhost")
+VisitCounter::Store::RedisStore.redis.flushdb
+
+describe VisitCounter do
+  describe "incrementing counters" do
+    before :each do
+      @d = DummyObject.new
+      @d.stub!(:id).and_return(1)
+      @d.nullify_counter_cache(:counter)
+    end
+
+    it "should increase the counter from nil / zero using the incr_counter method" do
+      @d.counter.should be_nil
+      @d.incr_counter(:counter)
+      @d.counter.should == 1
+    end
+
+    it "should not increase the counter if not passing the threshold" do
+      @d.counter = 100
+      @d.incr_counter(:counter)
+      @d.counter.should == 100
+      30.times do
+        @d.incr_counter(:counter)
+      end
+      @d.counter.should == 130
+
+      #should still be 143, because of the percentage thingie
+      30.times do
+        @d.incr_counter(:counter)
+      end
+      @d.counter.should == 130
+    end
+  end
+
+  describe "reading counters" do
+
+    before :each do
+      @d = DummyObject.new
+      @d.stub!(:id).and_return(1)
+      @d.nullify_counter_cache(:counter)
+    end
+
+    it "should allow to read an unchanged counter" do
+      @d.counter = 10
+      @d.read_counter(:counter).should == 10
+    end
+
+    it "should read an updated counter" do
+      @d.counter = 10
+      @d.incr_counter(:counter)
+      @d.read_counter(:counter).should == 11
+    end
+  end
+
+  describe "static threshold" do
+    before :each do
+      @d = DummyObject.new
+      @d.stub!(:id).and_return(1)
+      @d.nullify_counter_cache(:counter)
+      DummyObject.visit_counter_threshold_method = :static
+    end
+
+    it "should persist after setting a static threshold of 1" do
+      DummyObject.visit_counter_threshold = 1
+      @d.counter = 10
+      @d.incr_counter(:counter)
+      @d.counter.should == 11
+    end
+
+    it "should not persist after setting a static threshold of 2" do
+      DummyObject.visit_counter_threshold = 2
+      @d.counter = 10
+      @d.incr_counter(:counter)
+      @d.counter.should == 10
+
+      @d.incr_counter(:counter)
+      @d.counter.should == 12
+    end
+  end
+
+  describe "percent threshold" do
+    before :each do
+      @d = DummyObject.new
+      @d.stub!(:id).and_return(1)
+      @d.nullify_counter_cache(:counter)
+      DummyObject.visit_counter_threshold_method = :percent
+    end
+
+    it "should persist when passing a percent" do
+      DummyObject.visit_counter_threshold = 0.1
+      @d.counter = 10
+      @d.incr_counter(:counter)
+      @d.counter.should == 11
+    end
+  end
+
+  describe "locked objects" do
+    before :each do
+      @d = DummyObject.new
+      @d.stub!(:id).and_return(1)
+      @d.nullify_counter_cache(:counter)
+    end
+
+    it "should lock object when updating" do
+      VisitCounter::Store.engine.should_receive(:with_lock)
+      VisitCounter::Helper.persist(@d, 1, 1, :counter)
+    end
+
+    it "should not persist if object is locked" do
+      VisitCounter::Store.engine.stub!(:acquire_lock).and_return(false)
+      @d.should_not_receive(:update_attribute)
+      VisitCounter::Helper.persist(@d, 1, 1, :counter)
+    end
+
+    it "should persist if object is locked" do
+      VisitCounter::Store.engine.stub!(:acquire_lock).and_return(true)
+      @d.should_receive(:update_attribute)
+      VisitCounter::Helper.persist(@d, 1, 1, :counter)
+    end
+  end
+
+  describe "overriding the getter" do
+    before :all do
+      DummyObject.cached_counter :counter
+    end
+
+    before :each do
+      @d = DummyObject.new
+      @d.stub!(:id).and_return(1)
+      @d.nullify_counter_cache(:counter)
+    end
+
+    it "should define the methods" do
+      @d.should respond_to(:increase_counter)
+    end
+
+    it "should set the counter" do
+      @d.counter = 10
+      @d.increase_counter
+      @d.counter.should == 11
+    end
+  end
+  
+  describe "persist with callbacks" do
+    it "should use update_something method" do
+      @d = DummyObject.new
+      @d.class.update_callback_method = :update_something
+      @d.stub!(:id).and_return(1)
+      @d.should_receive(:update_something)
+      @d.incr_counter :counter
+    end  
+  end  
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require "visit-counter"
+
+  RSpec.configure do |config|
+    # config.mock_with :mocha
+    # config.mock_with :flexmock
+    # config.mock_with :rr
+    config.mock_with :rspec
+  end

data/visit-counter.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/visit-counter/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tom Caspy"]
+  gem.email         = ["tcaspy@gmail.com"]
+  gem.description   = %q{Simple counter increment which only writes to DB once in a while}
+  gem.summary       = %q{No need to write to db each visit, save the visits to a quick DB like redis or memcached, and write to the SQL db once reads exeeded a certain threshold}
+  gem.homepage      = "https://github.com/KensoDev/visit-counter"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "visit-counter-omri"
+  gem.require_paths = ["lib"]
+  gem.version       = VisitCounter::VERSION
+  
+  gem.add_development_dependency(%q<rspec>, [">= 0"])
+  gem.add_development_dependency(%q<rake>, ["~> 0.9.2"])
+  gem.add_dependency(%q<redis>, [">= 0"])
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: visit-counter-omri
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Tom Caspy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  name: rake
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+    none: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+    none: false
+- !ruby/object:Gem::Dependency
+  name: redis
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+description: Simple counter increment which only writes to DB once in a while
+email:
+- tcaspy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/visit-counter.rb
+- lib/visit-counter/key.rb
+- lib/visit-counter/store.rb
+- lib/visit-counter/store/abstract_store.rb
+- lib/visit-counter/store/rails_store.rb
+- lib/visit-counter/store/redis_store.rb
+- lib/visit-counter/version.rb
+- lib/visit-counter/visit_counter.rb
+- spec/lib/store_spec.rb
+- spec/lib/visit_counter_spec.rb
+- spec/spec_helper.rb
+- visit-counter.gemspec
+homepage: https://github.com/KensoDev/visit-counter
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: No need to write to db each visit, save the visits to a quick DB like redis
+  or memcached, and write to the SQL db once reads exeeded a certain threshold
+test_files:
+- spec/lib/store_spec.rb
+- spec/lib/visit_counter_spec.rb
+- spec/spec_helper.rb