duly_noted 0.1.0

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  # - jruby-18mode # JRuby in 1.8 mode
+  # - jruby-19mode # JRuby in 1.9 mode
+  - rbx-18mode
+  - rbx-19mode
+matrix:
+  allow_failures:
+    - rvm: 1.8.7
+# uncomment this line if your project needs to run something other than `rake`:
+script: bundle exec rspec spec

data/DOCS.md

@@ -0,0 +1,90 @@
+##Dependency
+* Redis
+
+The **DulyNoted** module contains four main methods:
+
+* `track`
+* `update`
+* `query`
+* `count`
+
+##Track
+
+_parameters: `metric_name`, `for`(optional), `generated_at`(optional), `meta`(optional), `ref_id`(optional)_
+
+`metric_name`: The name of the metric to track, ex: `page_views`, `downloads`
+
+`for`_(optional)_: A name space for your metric, ex: `home_page`
+
+`generated_at`_(optional)_: If the metric was generated in the past but is just now being logged, you can set the time it was generated at
+
+`meta`_(optional)_: A hash with whatever meta data fields you might want to store, ex: `ip_address`, `file_type`
+
+`ref_id`_(optional)_: If you need to reference the metric later, perhaps to add more metadata later on, you can set a reference id that you can use to update the metric
+
+##Update
+
+_parameters: `metric_name`, `ref_id`, `for`(required if set when created), `meta`(optional)_
+
+The meta hash will not overwrite the old meta hash but be merged with it, with the new one overwriting conflicts.
+
+`metric_name`: The name of the metric to update, ex: `page_views`, `downloads`
+
+`ref_id`: The reference ID that you set when you called `track`
+
+`for`_(required if you set `for` when you generated the metric)_: A name space for your metric, ex: `home_page`
+
+`meta`_(optional)_: A hash with whatever meta data fields you might want to store, or update ex: `ip_address`, `file_type`, `time_left`
+
+###Usage
+
+    DulyNoted.update("page_views", "a_unique_id", for: "home_page", meta: { time_on_page: 30 })
+
+##Query
+
+_parameters: `metric_name`, `for`(required if set when created), `time_start`(optional), `time_end`(optional)_
+
+Query will return an array of all the metadata in chronological order from a time range, or for the whole data set.
+
+`metric_name`: The name of the metric to query, ex: `page_views`, `downloads`
+
+`for`_(required if you set `for` when you generated the metric)_: A name space for your metric, ex: `home_page`
+
+`time_start`_(optional)_: The start of the time range to grab the data from.
+
+`time_end`_(optional)_: The end of the time range to grab the data from.
+
+###Usage
+
+    DulyNoted.query("page_views",
+      for: "home_page",
+      time_start: 1.day.ago,
+      time_end: Time.now)
+
+##Count
+
+_parameters: `metric_name`, `for`(required if set when created), `time_start`(optional), `time_end`(optional)_
+
+Count will return the number of events logged in a given time range, or if no time range is given, the total count.
+
+`metric_name`: The name of the metric to query, ex: `page_views`, `downloads`
+
+`for`_(required if you set `for` when you generated the metric)_: A name space for your metric, ex: `home_page`
+
+`time_start`_(optional)_: The start of the time range to grab the data from.
+
+`time_end`_(optional)_: The end of the time range to grab the data from.
+
+###Usage
+
+    DulyNoted.count("page_views",
+      for: "home_page",
+      time_start: 1.day.ago,
+      time_end: Time.now)
+
+##Redis
+
+DulyNoted will try to connect to Redis's default url and port if you don't specify a Redis connection URL. You can set the url with the method
+
+    DulyNoted.redis = REDIS_URL
+

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,13 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+
+guard :bundler do
+  watch('Gemfile')
+end
+

data/README.md

@@ -0,0 +1,52 @@
+#Duly Noted
+[![Build Status](https://secure.travis-ci.org/willcosgrove/duly_noted.png?branch=master)](http://travis-ci.org/willcosgrove/duly_noted)
+
+Duly noted is a redis backed stats and metrics tracker.  It works as follows:
+
+    DulyNoted.track("page_views", for: "homepage")
+
+This would log one page view for the home page.  Then to see how many page views the home page has gotten, you would simply call:
+
+    DulyNoted.count("page_views", for: "homepage")
+
+You can also store meta data with your metrics by passing your data in a hash to the `meta` key like so:
+
+    DulyNoted.track("page_views", for: "homepage", meta: {user_agent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_2) AppleWebKit/535.2 (KHTML, like Gecko) Chrome/15.0.874.121 Safari/535.2", ip_address: "128.194.3.138"})
+
+If the metric was generated in the past but is just now being logged, you can alter it's time stamp with the `generated_at` key:
+
+    DulyNoted.track("page_views", for: "homepage", generated_at: 10.minutes.ago)
+
+To get the count for a particular time range, you can use the `time_start` and `time_end` keys in the count call like so:
+
+    DulyNoted.count("page_views", for: "homepage", time_start: 1.day.ago, time_end: Time.now)
+
+You can also just specify a `time_range` like so:
+
+    DulyNoted.count("page_views", for: "homepage", time_range: 1.day.ago..Time.now)
+
+This will return the page view count for the home page for the past day.
+
+##What's New
+
+### 0.1.0
+
+* Added the `time_range` option to `count`, and `query`
+
+* Added the `meta_fields` option to `query`, which takes an array of fields to pull out from the meta hash
+
+* Added the `ref_id` option to `query`, which takes a reference id and will return an array with one meta hash.  I was going back and forth on whether or not it should wrap the hash in an array.  It doesn't need to be, but I thought, just to make it consistant with it's usual output, I should make it return an array.
+
+* Enough bug fixes to make it production ready! Yay!
+
+
+##To Do
+
+* Count by meta fields: How many page views from each browser?
+
+* A `chart` method which would take a `time_start`, `time_end`, and a `granularity` which would allow you to easily get the per hour for each hour for the past day, for example.
+
+* Maybe some Rails view helpers to generate some code for a Javascript charting library, or Google Charts API.
+
+##Contributing
+If you want to help, you should do it.  Fork it, fix it, and send me a pull request.  I will be delighted.

data/Rakefile

@@ -0,0 +1,19 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end
+
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end

data/duly_noted.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/duly_noted/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Will Cosgrove"]
+  gem.email         = ["will@willcosgrove.com"]
+  gem.description   = %q{keep detailed metrics on your project with a speedy, powerful redis backend.}
+  gem.summary       = %q{a simple redis based stat-tracker}
+  gem.homepage      = "http://github.com/willcosgrove/duly_noted"
+
+  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          = "duly_noted"
+  gem.require_paths = ["lib"]
+  gem.version       = DulyNoted::VERSION
+  gem.add_dependency("redis")
+  gem.add_development_dependency("rspec")
+  gem.add_development_dependency("rake")
+  gem.add_development_dependency("rb-fsevent")
+  gem.add_development_dependency("guard-rspec")
+  gem.add_development_dependency("growl")
+  gem.add_development_dependency("guard-bundler")
+  gem.add_development_dependency("chronic")
+end

data/lib/duly_noted.rb

@@ -0,0 +1,270 @@
+# Duly noted is a redis backed stats and metrics tracker.  It works as follows:
+# 
+#     DulyNoted.track("page_views",
+#       for: "home_page")
+# 
+# This would log one page view for the home page.  Then to see how many page views the home page has gotten, you would simply call:
+# 
+#     DulyNoted.count("page_views",
+#       for: "home_page")
+# 
+# You can also store meta data with your metrics by passing your data in a hash to the `meta` key like so:
+# 
+#     DulyNoted.track("page_views",
+#       for: "home_page",
+#       meta: {
+#         user_agent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_2)...",
+#         ip_address: "128.194.3.138"
+#       })
+# 
+# If the metric was generated in the past but is just now being logged, you can alter it's time stamp with the `generated_at` key:
+# 
+#     DulyNoted.track("page_views",
+#       for: "home_page",
+#       generated_at: 10.minutes.ago)
+# 
+# To get the count for a particular time range, you can use the `time_start` and `time_end` keys in the count call like so:
+# 
+#     DulyNoted.count("page_views",
+#       for: "home_page",
+#       time_start: 1.day.ago,
+#       time_end: Time.now)
+# 
+# This will return the page view count for the home page for the past day.
+#
+# You can also just specify a `time_range` like so:
+#
+#     DulyNoted.count("page_views",
+#       for: "homepage",
+#       time_range: 1.day.ago..Time.now)
+
+# ##Dependency
+# * Redis
+
+require "redis"
+require "uri"
+require "duly_noted/helpers"
+require "duly_noted/version"
+
+# The **DulyNoted** module contains four main methods:
+# 
+# * `track`
+# * `update`
+# * `query`
+# * `count`
+
+module DulyNoted
+  include Helpers
+  extend self # the following are class methods
+  
+  # ##Track
+  # 
+  # _parameters: `metric_name`, `for`(optional), `generated_at`(optional), `meta`(optional), `ref_id`(optional)_
+  # 
+  # `metric_name`: The name of the metric to track, ex: `page_views`, `downloads`
+  # 
+  # `for`_(optional)_: A name space for your metric, ex: `home_page`
+  # 
+  # `generated_at`_(optional)_: If the metric was generated in the past but is just now being logged, you can set the time it was generated at
+  # 
+  # `meta`_(optional)_: A hash with whatever meta data fields you might want to store, ex: `ip_address`, `file_type`
+  # 
+  # `ref_id`_(optional)_: If you need to reference the metric later, perhaps to add more metadata later on, you can set a reference id that you can use to update the metric
+    
+  def track(metric_name, options={})
+    options = {:generated_at => Time.now}.merge(options)
+    key = normalize(metric_name)
+    key << ":#{options[:for]}" if options[:for]
+    DulyNoted.redis.zadd key, options[:generated_at].to_f, "#{key}:#{options[:generated_at].to_f}:meta"
+    DulyNoted.redis.set "#{key}:#{options[:ref_id]}", "#{key}:#{options[:generated_at].to_f}:meta" if options[:ref_id] # set alias key
+    DulyNoted.redis.mapped_hmset "#{key}:#{options[:generated_at].to_f}:meta", options[:meta] if options[:meta] # set meta data
+  end
+  
+  # ##Update
+  # 
+  # _parameters: `metric_name`, `ref_id`, `for`(required if set when created), `meta`(optional)_
+  # 
+  # The meta hash will not overwrite the old meta hash but be merged with it, with the new one overwriting conflicts.
+  # 
+  # `metric_name`: The name of the metric to track, ex: `page_views`, `downloads`
+  # 
+  # `ref_id`: The reference ID that you set when you called `track`
+  # 
+  # `for`_(required if you set `for` when you generated the metric)_: A name space for your metric, ex: `home_page`
+  # 
+  # `meta`_(optional)_: A hash with whatever meta data fields you might want to store, or update ex: `ip_address`, `file_type`, `time_left`
+  # 
+  # ###Usage
+  # 
+  #     DulyNoted.update("page_views",
+  #       "a_unique_id",
+  #       for: "home_page",
+  #       meta: { time_on_page: 30 })
+  
+  def update(metric_name, ref_id, options={})
+    key = normalize(metric_name)
+    key << ":#{options[:for]}" if options[:for]
+    key << ":#{ref_id}"
+    real_key = DulyNoted.redis.get key
+    DulyNoted.redis.mapped_hmset real_key, options[:meta] if options[:meta] 
+  end
+  
+  # ##Query
+  # 
+  # _parameters: `metric_name`, `for`(required if set when created), `time_start`(optional), `time_end`(optional)_
+  # 
+  # Query will return an array of all the metadata in chronological order from a time range, or for the whole data set.
+  # 
+  # `metric_name`: The name of the metric to query, ex: `page_views`, `downloads`
+  # 
+  # `for`_(required if you set `for` when you generated the metric)_: A name space for your metric, ex: `home_page`
+  #
+  # `ref_id`: _(optional)_: The reference ID that you set when you called `track` (if you set this, the time restraints is ignored)
+  #
+  # `meta_fields` _(optional)_: An array of fields to retrieve from the meta hash.  If not specified, the entire hash will be grabbed.  Fields will be converted to strings, because redis converts all hash keys and values to strings.
+  # 
+  # `time_start`_(optional)_: The start of the time range to grab the data from.
+  # 
+  # `time_end`_(optional)_: The end of the time range to grab the data from.
+  #
+  # `time_range _(optional)_: Alternatively you can specify a time range, instead of `time_start` and `time_end`.
+  # 
+  # ###Usage
+  # 
+  #     DulyNoted.query("page_views",
+  #       for: "home_page",
+  #       time_start: 1.day.ago,
+  #       time_end: Time.now)
+  #
+  #
+  #     DulyNoted.query("page_views",
+  #       for: "home_page",
+  #       time_range: 1.day.ago..Time.now)
+  
+  def query(metric_name, options={})
+    key = normalize(metric_name)
+    parse_time_range(options)
+    key << ":#{options[:for]}" if options[:for]
+    if options[:ref_id]
+      key << ":#{options[:ref_id]}"
+      real_key = DulyNoted.redis.get key
+      if options[:meta_fields]
+        options[:meta_fields].collect! { |x| x.to_s }
+        result = {}
+        options[:meta_fields].each do |field|
+          result[field] = DulyNoted.redis.hget real_key, field
+        end
+        results = [result]
+      else
+        results = [DulyNoted.redis.hgetall(real_key)]
+      end
+    else
+      grab_results = Proc.new do |metric|
+        if options[:meta_fields]
+          options[:meta_fields].collect! { |x| x.to_s }
+          result = {}
+          options[:meta_fields].each do |field|
+            result[field] = DulyNoted.redis.hget metric, field
+          end
+          result
+        else
+          DulyNoted.redis.hgetall metric
+        end
+      end
+      if options[:time_start] && options[:time_end]
+        results = DulyNoted.redis.zrangebyscore(key, options[:time_start].to_f, options[:time_end].to_f).collect(&grab_results)
+      else
+        results = DulyNoted.redis.zrange(key, 0, -1).collect(&grab_results)
+      end
+    end
+    return results
+  end
+  
+  # ##Count
+  # 
+  # _parameters: `metric_name`, `for`(required if set when created), `time_start`(optional), `time_end`(optional)_
+  # 
+  # Count will return the number of events logged in a given time range, or if no time range is given, the total count.
+  # 
+  # `metric_name`: The name of the metric to query, ex: `page_views`, `downloads`
+  # 
+  # `for`_(required if you set `for` when you generated the metric)_: A name space for your metric, ex: `home_page`
+  # 
+  # `time_start`_(optional)_: The start of the time range to grab the data from.
+  # 
+  # `time_end`_(optional)_: The end of the time range to grab the data from.
+  #
+  # `time_range _(optional)_: Alternatively you can specify a time range, instead of `time_start` and `time_end`.
+  # 
+  # ###Usage
+  # 
+  #     DulyNoted.count("page_views",
+  #       for: "home_page",
+  #       time_start: Time.now,
+  #       time_end: 1.day.ago)
+  #
+  #
+  #     DulyNoted.count("page_views",
+  #        for: "home_page",
+  #        time_range: Time.now..1.day.ago)
+  
+  def count(metric_name, options={})
+    parse_time_range(options)
+    key = normalize(metric_name)
+    keys = []
+    if options[:for]
+      key << ":#{options[:for]}"
+    else
+      keys << DulyNoted.redis.keys("#{key}*")
+      keys - DulyNoted.redis.keys("#{key}*:meta")
+      keys - DulyNoted.redis.keys("#{key}:*:")
+      keys.flatten!
+    end
+    if keys.empty?
+      if options[:time_start] && options[:time_end]
+        return DulyNoted.redis.zcount(key, options[:time_start].to_f, options[:time_end].to_f)
+      else 
+        return DulyNoted.redis.zcard(key)
+      end
+    else
+      sum = 0
+      if options[:time_start] && options[:time_end]
+        keys.each do |key|
+          sum += DulyNoted.redis.zcount(key, options[:time_start].to_f, options[:time_end].to_f)
+        end
+        return sum
+      else
+        keys.each do |key|
+          sum += DulyNoted.redis.zcard(key)
+        end
+        return sum
+      end
+    end
+  end
+  
+  # ##Redis
+  # 
+  # DulyNoted will try to connect to Redis's default url and port if you don't specify a Redis connection URL. You can set the url with the method
+  # 
+  #     DulyNoted.redis = REDIS_URL
+  
+  def redis=(url)
+    @redis = nil
+    @redis_url = url
+    redis
+  end
+
+  def redis
+    @redis ||= (
+      url = URI(@redis_url || "redis://127.0.0.1:6379/0")
+
+      Redis.new({
+        :host => url.host,
+        :port => url.port,
+        :db => url.path[1..-1],
+        :password => url.password
+      })
+    )
+  end
+
+end

data/lib/duly_noted/helpers.rb

@@ -0,0 +1,14 @@
+module DulyNoted
+  module Helpers
+    def normalize(str)
+      str.downcase.gsub(/[^a-z0-9 ]/i, '').strip
+    end
+
+    def parse_time_range(options)
+      if options[:time_range]
+        options[:time_start] = options[:time_range].first
+        options[:time_end] = options[:time_range].last
+      end
+    end
+  end
+end

data/lib/duly_noted/version.rb

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

data/spec/duly_noted_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe DulyNoted do
+  before :each do
+    DulyNoted.redis.flushall
+  end
+
+  describe "#track" do
+    it "keeps an accurate count of events" do
+      2.times { DulyNoted.track "page_views" }
+      DulyNoted.count("page_views").should eq(2)
+    end
+    it "separates by context" do
+      2.times { DulyNoted.track "page_views", :for => "home" }
+      5.times { DulyNoted.track "page_views", :for => "contact_us" }
+      DulyNoted.count("page_views", :for => "home").should eq(2)
+      DulyNoted.count("page_views", :for => "contact_us").should eq(5)
+    end
+    it "stores metadata" do
+      DulyNoted.track "page_views", :meta => {:open => true}
+      DulyNoted.query("page_views").should include({"open" => "true"})
+    end
+    it "can track past events" do
+      DulyNoted.track "page_views", :generated_at => Time.now-10
+      DulyNoted.count "page_views", :time_range => Time.now-11..Time.now-9
+    end
+  end
+
+  describe "#update" do
+    it "overwrites duplicate keys" do
+      DulyNoted.track "page_views", :meta => {:seconds_open => 0}, :ref_id => "unique"
+      DulyNoted.update "page_views", "unique", :meta => {:seconds_open => 5}
+      DulyNoted.query("page_views").should include({"seconds_open" => "5"})
+      DulyNoted.query("page_views").should_not include({"seconds_open" => "0"})
+    end
+    it "doesn't replace old hash" do
+      DulyNoted.track "page_views", :meta => {:seconds_open => 0}, :ref_id => "unique"
+      DulyNoted.update "page_views", "unique", :meta => {:ip_address => "19.27.182.32"}
+      DulyNoted.query("page_views").should include({"seconds_open" => "0", "ip_address" => "19.27.182.32"})
+    end
+  end
+
+  describe "#query" do
+    it "should grab entire meta hash" do
+      DulyNoted.track "page_views", :meta => {:seconds_open => 0, :browser => "chrome"}
+      DulyNoted.query("page_views").should include({"seconds_open" => "0", "browser" => "chrome"})
+    end
+    it "can query a certain ref_id" do
+      DulyNoted.track "page_views", :meta => {:seconds_open => 0, :browser => "chrome"}, :ref_id => "unique"
+      DulyNoted.track "page_views", :meta => {:seconds_open => 10, :browser => "firefox"}
+      DulyNoted.query("page_views", :ref_id => "unique").should include({"seconds_open" => "0", "browser" => "chrome"})
+      DulyNoted.query("page_views", :ref_id => "unique").should_not include({"seconds_open" => "10", "browser" => "firefox"})
+    end
+    it "can grab only specific fields from the hash" do
+      DulyNoted.track "page_views", :meta => {:seconds_open => 0, :browser => "chrome"}
+      DulyNoted.query("page_views", :meta_fields => [:browser]).should include({"browser" => "chrome"})
+      DulyNoted.query("page_views", :meta_fields => [:browser]).should_not include({"seconds_open" => "0"})
+      DulyNoted.track "downloads", :meta => {:file_name => "rules.pdf", :browser => "chrome"}, :ref_id => "unique"
+      DulyNoted.query("downloads", :ref_id => "unique", :meta_fields => [:browser]).should include({"browser" => "chrome"})
+      DulyNoted.query("downloads", :ref_id => "unique", :meta_fields => [:browser]).should_not include({"file_name" => "rules.pdf"})
+    end
+    it "can get only meta hashes from a certain time range" do
+      5.times { DulyNoted.track "page_views", :meta => {:seconds_open => 5, :browser => "chrome"} }
+      sleep 0.5
+      5.times { DulyNoted.track "page_views", :meta => {:seconds_open => 0, :browser => "firefox"} }
+      DulyNoted.query("page_views", :time_start => Time.now-0.5, :time_end => Time.now).should include({"seconds_open" => "0", "browser" => "firefox"})
+      DulyNoted.query("page_views", :time_range => Time.now-0.5..Time.now).should include({"seconds_open" => "0", "browser" => "firefox"})
+      DulyNoted.query("page_views", :time_start => Time.now-0.5, :time_end => Time.now).should_not include({"seconds_open" => "5", "browser" => "chrome"})
+      DulyNoted.query("page_views", :time_range => Time.now-0.5..Time.now).should_not include({"seconds_open" => "5", "browser" => "chrome"})
+    end
+  end
+
+  describe "#count" do
+    it "can count events in between a time range" do
+      5.times { DulyNoted.track "page_views" }
+      sleep 0.2
+      5.times { DulyNoted.track "page_views" }
+      DulyNoted.count("page_views", :time_start => Time.now-0.2, :time_end => Time.now).should eq(5)
+      DulyNoted.count("page_views", :time_range => Time.now-0.2..Time.now).should eq(5)
+    end
+    it "can count all of one type of metric" do
+      5.times { DulyNoted.track "page_views", :for => "home" }
+      5.times { DulyNoted.track "page_views", :for => "contact_us" }
+      DulyNoted.count("page_views").should eq(10)
+    end
+    it "can count all of one type between a time range" do
+      5.times { DulyNoted.track "page_views", :for => "home" }
+      5.times { DulyNoted.track "page_views", :for => "contact_us" }
+      sleep 0.2
+      5.times { DulyNoted.track "page_views", :for => "home" }
+      5.times { DulyNoted.track "page_views", :for => "contact_us" }
+      DulyNoted.count("page_views", :time_start => Time.now-0.2, :time_end => Time.now).should eq(10)
+      DulyNoted.count("page_views", :time_range => Time.now-0.2..Time.now).should eq(10)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+unless Kernel.respond_to?(:require_relative)
+  module Kernel
+    def require_relative(path)
+      require File.join(File.dirname(caller[0]), path.to_str)
+    end
+  end
+end
+
+require_relative "../lib/duly_noted"
+require 'chronic'

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: duly_noted
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Will Cosgrove
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &70245889112380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70245889112380
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70245889111680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70245889111680
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70245889110680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70245889110680
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: &70245889109440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70245889109440
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &70245889108340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70245889108340
+- !ruby/object:Gem::Dependency
+  name: growl
+  requirement: &70245889107640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70245889107640
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: &70245889106880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70245889106880
+- !ruby/object:Gem::Dependency
+  name: chronic
+  requirement: &70245889106080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70245889106080
+description: keep detailed metrics on your project with a speedy, powerful redis backend.
+email:
+- will@willcosgrove.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .DS_Store
+- .gitignore
+- .travis.yml
+- DOCS.md
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- duly_noted.gemspec
+- lib/duly_noted.rb
+- lib/duly_noted/helpers.rb
+- lib/duly_noted/version.rb
+- spec/duly_noted_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/willcosgrove/duly_noted
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: a simple redis based stat-tracker
+test_files:
+- spec/duly_noted_spec.rb
+- spec/spec_helper.rb