duly_noted 0.1.0 → 1.0.0

data/DOCS.md

@@ -1,58 +1,74 @@
 ##Dependency
 * Redis
 
-The **DulyNoted** module contains four main methods:
+The **DulyNoted** module contains five main methods:
 
 * `track`
 * `update`
 * `query`
 * `count`
+* `chart`
 
-##Track
+##Parameter Descriptions
+`metric_name`: The name of the metric to track, ex: `page_views`, `downloads`
 
-_parameters: `metric_name`, `for`(optional), `generated_at`(optional), `meta`(optional), `ref_id`(optional)_
+`for`: A name space for your metric, ex: `home_page`
+*New in v1.0.0*: `for` can be an array of nested contexts.  For example, say you had users, and users had videos, and you wanted to track plays.  Your `for` might look like `["user_1", "video_6"]`.  Now when you're doing `count`s or `quer`ies, you can specify just `for: "user_1"` to get all of the plays for user_1's videos, or you can specify `for: ["user_1", "video_6"]` to get just that video's plays.  It is important to note that `for`s are nested, so you cannot ask for a count `for: "video_6"`, it must always be referenced through `user_1`.
 
-`metric_name`: The name of the metric to track, ex: `page_views`, `downloads`
+`generated_at`: If the metric was generated in the past but is just now being logged, you can set the time it was generated at
 
-`for`_(optional)_: A name space for your metric, ex: `home_page`
+`meta`: A hash with whatever meta data fields you might want to store, ex: `ip_address`, `file_type`
 
-`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_fields`: 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.
 
-`meta`_(optional)_: A hash with whatever meta data fields you might want to store, ex: `ip_address`, `file_type`
+`ref_id`: 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.  The `ref_id` must be unique across `metric_name`s.
 
-`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
+`editable_for`: If you want to clear `ref_id`s out, you can set the metric to only be editable for a certain amount of time.  `editable_for` is defined in seconds.  After that amount of time, you will no longer be able to edit the meta data, and you may use that `ref_id` again.  By default, `ref_id`s never expire.
 
-##Update
+`time_start`: The start of the time range to grab the data from.  **Important:**  `time_start` should always be the time farthest in the past.
+
+`time_end`: The end of the time range to grab the data from.  **Important:** `time_end` should always be the time closest to the present.
 
-_parameters: `metric_name`, `ref_id`, `for`(required if set when created), `meta`(optional)_
+`time_range`: A Range object made up of two Time objects.  The beginning of the Range should be farthest in the past, and the end of the range should be closest to the present.  If `time_range` is defined, `time_end` and `time_start` do not need to be.
 
-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`
+##Track
 
-`for`_(required if you set `for` when you generated the metric)_: A name space for your metric, ex: `home_page`
+_parameters: `metric_name`, `for`(optional), `generated_at`(optional), `meta`(optional), `ref_id`(optional), `editable_for`(optional)_
 
-`meta`_(optional)_: A hash with whatever meta data fields you might want to store, or update ex: `ip_address`, `file_type`, `time_left`
+Use track to track an event, like a page view, or a download.  Use the `for` option to give an event a context.  For instance, for page views, you might set `for` to `home_page`, so that you know which page was viewed.  You can also store metadata along with your metric with the `meta` hash.  If you need to update that `meta` hash at a later time, you can set a `ref_id`, which can be used to tell `#update` exactly which metric you want to update.  `ref_id`s have to be unique across `metric_name`s, and if you want to free up your `ref_id`s, you can set them to expire after a certain number of seconds with `editable_for`.
 
 ###Usage
 
-    DulyNoted.update("page_views", "a_unique_id", for: "home_page", meta: { time_on_page: 30 })
+	DulyNoted.track("page_views", for: "home", meta: {browser: "chrome"})
+	
+	DulyNoted.track("video_plays", for: ["user_7261", "video_917216"], meta: {amount_watched: 0})
+	
+	DulyNoted.track("purchases", for: "user_281", generated_at: 1.day.ago, ref_id: "pid_28172", editable_for: 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.
+##Update
 
-`metric_name`: The name of the metric to query, ex: `page_views`, `downloads`
+_parameters: `metric_name`, `ref_id`, `meta`(optional), `editable_for`(optional)_
 
-`for`_(required if you set `for` when you generated the metric)_: A name space for your metric, ex: `home_page`
+Use update to add, or edit the metadata stored with a metric.  You can optionally set the `editable_for` option which will override any setting set by track.  So if it was set to expire in 30 seconds, and in 20 seconds you called update with `editable_for` set to `30`, it would be editable for 30 seconds from the moment you updated it.
+
+###Usage
 
-`time_start`_(optional)_: The start of the time range to grab the data from.
+	DulyNoted.track("page_views", ref_id: "a_unique_id", meta: {time_on_page: 0, browser: "chrome"})
+	
+    DulyNoted.update("page_views", "a_unique_id", meta: { time_on_page: 30 }, editable_for: 30)
+
+
+
+##Query
+
+_parameters: `metric_name`, `for`(optional), `meta_fields`(optional), `time_start`(optional), `time_end`(optional), `time_range`(optional)_
+
+Query will return an array of all the metadata in chronological order from a time range, or for the whole data set.  If for is specified, it will limit it by that context.  For instance, if you have `track`ed several page views with `for` set to the name of the page that was viewed, you could query with `for` set to `home_page` to get all of the metadata from the page views from the home page, or you could leave off the `for`, and return all of the metadata for all of the page views, across all pages.
 
-`time_end`_(optional)_: The end of the time range to grab the data from.
 
 ###Usage
 
@@ -63,17 +79,9 @@ Query will return an array of all the metadata in chronological order from a tim
 
 ##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`
+_parameters: `metric_name`, `for`(optional), `time_start`(optional), `time_end`(optional), `time_range`(optional)_
 
-`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.
+Count will return the number of events logged in a given time range, or if no time range is given, the total count.  As with `#query`, you can specify `for` to return a subset of counts, or you can leave it off to get the count across the whole `metric_name`.
 
 ###Usage
 
@@ -81,6 +89,62 @@ Count will return the number of events logged in a given time range, or if no ti
       for: "home_page",
       time_start: 1.day.ago,
       time_end: Time.now)
+      
+
+##Chart
+
+_parameters: `metric_name`, `data_points`(required),`for`(optional), `time_start`(optional), `time_end`(optional), `time_range`(optional)_
+
+Chart is a little complex, but I'll try to explain all of the possibilities.  It's main purpose is to pull out your data and prepare it in a way that makes it easy to chart.  The smallest amount of input it will take is just a `metric_name` and an amount of `data_points` to capture.  This will check the time of the earliest known data point, and the time of the last known data point, and run chart with those values as the `time_start` and `time_end` respectively.  It will take the amount of time that that spans, and divide it by the number of data points you asked for, and will split the time up evenly, and return a hash of times, and counts.  If you specify both a `time_start` and a `time_end`, and a number of `data_points`, then it will divide the amount of time that that spans and will return a hash of times and counts.  The other option is that you can specify either a `time_start` OR a `time_end` and a `step` and a number of `data_points`.  This will start at whatever time you specified, and (if it's `time_end`) count down by the step (if you specified `time_start`, it would count up), as many times as the number of data points you requested.
+
+###Usage
+
+	DulyNoted.chart("page_views",
+		:time_range => 1.month.ago..Time.now,
+		:step => 1.day)
+		
+	DulyNoted.chart("page_views",
+		:time_range => 1.day.ago..Time.now,
+		:data_points => 12)
+		
+	DulyNoted.chart("page_views",
+		:time_start => 1.day.ago,
+		:step => 1.hour,
+		:data_points => 12)
+		
+	DulyNoted.chart("downloads",
+		:time_end => Time.now,
+		:step => 1.month,
+		:data_points => 12)
+		
+	DulyNoted.chart("page_views",
+		:data_points => 100)
+	
+
+Chart can be a little confusing but it's pretty powerful, so play around with it.
+
+##Magic
+
+###count_x_by_y
+
+If you want to count a number of events by a meta field, you can use this magic command.  So imagine this scenario:
+
+	DulyNoted.track("page_views", meta: {browser: "chrome"})
+	
+And you wanted to see a break down of page views by various browsers, you can call `DulyNoted.count_page_views_by_browser` and you'd get a hash that looked something like this:
+
+	{"chrome" => 2913, "firefox" => 5281, "IE" => 7182, "safari" => 3213}
+
+So that method will work as soon as you've tracked something with that metric name.  If you try to call the method on a metric that you haven't yet tracked you will get a `DulyNoted::NotValidMetric`.  But if you reference a meta field that didn't exist, you'd just get a hash that looks like
+
+	{nil => 1}
+	
+##Behind the curtain (metaprogramming)
+
+###method_missing
+
+As I'm sure you're aware, method_missing is the magic tool for ruby developers to define dynamic methods like the above `count_x_by_y`, which is exactly what we use it for.
+
 
 ##Redis
 

data/Guardfile

@@ -9,5 +9,6 @@ end
 
 guard :bundler do
   watch('Gemfile')
+  watch('*.gemspec')
 end
 

data/README.md

@@ -1,3 +1,5 @@
+_Currently being updated for v1.0.0..._
+
 #Duly Noted
 [![Build Status](https://secure.travis-ci.org/willcosgrove/duly_noted.png?branch=master)](http://travis-ci.org/willcosgrove/duly_noted)
 
@@ -27,6 +29,18 @@ You can also just specify a `time_range` like so:
 
 This will return the page view count for the home page for the past day.
 
+##Install
+
+You probably already guessed it, but to install just
+
+    gem install duly_noted
+
+or add 
+
+    gem 'duly_noted'
+
+to your `gemfile` and run `bundle install`
+
 ##What's New
 
 ### 0.1.0

data/duly_noted.gemspec

@@ -4,8 +4,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.description   = %q{a simple redis based stat-tracker}
+  gem.summary       = %q{keep detailed metrics on your project with a speedy, powerful redis backend.}
   gem.homepage      = "http://github.com/willcosgrove/duly_noted"
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
@@ -19,7 +19,9 @@ Gem::Specification.new do |gem|
   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("growl")
   gem.add_development_dependency("guard-bundler")
   gem.add_development_dependency("chronic")
+  gem.add_development_dependency("timecop")
+  gem.add_development_dependency("ruby_gntp")
 end

data/lib/duly_noted/helpers.rb

@@ -1,14 +1,60 @@
 module DulyNoted
   module Helpers
+    
+    def build_key(str, validity_test=true)
+      if validity_test
+        raise NotValidMetric if !valid_metric?(str) && !(caller[0] =~ /track/)
+      end
+      return "dn:" + normalize(str)
+    end
+
     def normalize(str)
       str.downcase.gsub(/[^a-z0-9 ]/i, '').strip
     end
 
+    def assemble_for(options)
+      case
+      when options[:for].is_a?(String)
+        ":#{normalize(options[:for])}"
+      when options[:for].is_a?(Array)
+        ":" << options[:for].collect{ |x| normalize(x) }.join(":")
+      else
+        ""
+      end
+    end
+
+    def find_keys(key)
+      keys = []
+      keys += DulyNoted.redis.keys("#{key}*")
+      keys -= DulyNoted.redis.keys("#{key}:*:meta")
+      keys -= DulyNoted.redis.keys("#{key}:ref:*")
+      keys -= DulyNoted.redis.keys("#{key}*fields")
+    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
+
+    def metrics
+      DulyNoted.redis.smembers build_key("metrics", false)
+    end
+
+    def valid_metric?(metric_name)
+      DulyNoted.redis.sismember build_key("metrics", false), build_key(metric_name, false)
+    end
+
+    def fields_for(metric_name, options={})
+      key = build_key(metric_name)
+      key << assemble_for(options)
+      keys = find_keys(key)
+      fields = []
+      keys.each do |key|
+        fields += DulyNoted.redis.smembers("#{key}:fields")
+      end
+      fields
+    end
   end
 end

data/lib/duly_noted/updater.rb

@@ -0,0 +1,30 @@
+require "duly_noted/version"
+
+module DulyNoted
+  module Updater
+    def update_schema(schema_version, redis)
+      # magic updating!
+      redis.set "dn:version", VERSION
+      puts "All up to date"
+      return true
+    end
+
+    def check_schema(redis)
+      schema_version = redis.get "dn:version"
+      if !schema_version.nil?
+        schema_version = schema_version.split(".")
+        current_version = VERSION.split(".")
+        if schema_version[0] != current_version[0]
+          puts "Your duly_noted schema needs to be updated"
+          if update_schema(schema_version.join("."), redis)
+            check_schema(redis)
+          else
+            raise UpdateError
+          end
+        end
+      end
+      redis.set "dn:version", VERSION
+      return redis
+    end
+  end
+end

data/lib/duly_noted/version.rb

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

data/lib/duly_noted.rb

@@ -45,89 +45,120 @@ require "redis"
 require "uri"
 require "duly_noted/helpers"
 require "duly_noted/version"
+require "duly_noted/updater"
+
+# The **DulyNoted** module contains five main methods:
 
-# The **DulyNoted** module contains four main methods:
-# 
 # * `track`
 # * `update`
 # * `query`
 # * `count`
+# * `chart`
 
 module DulyNoted
   include Helpers
+  include Updater
   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`
+
+# ##Parameter Descriptions
+# `metric_name`: The name of the metric to track, ex: `page_views`, `downloads`
+# 
+# `for`: A name space for your metric, ex: `home_page`
+# *New in v1.0.0*: `for` can be an array of nested contexts.  For example, say you had users, and users had videos, and you wanted to track plays.  Your `for` might look like `["user_1", "video_6"]`.  Now when you're doing `count`s or `quer`ies, you can specify just `for: "user_1"` to get all of the plays for user_1's videos, or you can specify `for: ["user_1", "video_6"]` to get just that video's plays.  It is important to note that `for`s are nested, so you cannot ask for a count `for: "video_6"`, it must always be referenced through `user_1`.
+# 
+# `generated_at`: If the metric was generated in the past but is just now being logged, you can set the time it was generated at
+# 
+# `meta`: A hash with whatever meta data fields you might want to store, ex: `ip_address`, `file_type`
+# 
+# `meta_fields`: 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.
+# 
+# `ref_id`: 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.  The `ref_id` must be unique across `metric_name`s.
+# 
+# `editable_for`: If you want to clear `ref_id`s out, you can set the metric to only be editable for a certain amount of time.  `editable_for` is defined in seconds.  After that amount of time, you will no longer be able to edit the meta data, and you may use that `ref_id` again.  By default, `ref_id`s never expire.
+# 
+# `time_start`: The start of the time range to grab the data from.  **Important:**  `time_start` should always be the time farthest in the past.
+# 
+# `time_end`: The end of the time range to grab the data from.  **Important:** `time_end` should always be the time closest to the present.
+# 
+# `time_range`: A Range object made up of two Time objects.  The beginning of the Range should be farthest in the past, and the end of the range should be closest to the present.  If `time_range` is defined, `time_end` and `time_start` do not need to be.
+
+  #   ##Track
+
+  # _parameters: `metric_name`, `for`(optional), `generated_at`(optional), `meta`(optional), `ref_id`(optional), `editable_for`(optional)_
+
+  # Use track to track an event, like a page view, or a download.  Use the `for` option
+  # to give an event a context.  For instance, for page views, you might set `for` to
+  # `home_page`, so that you know which page was viewed.  You can also store metadata
+  # along with your metric with the `meta` hash.  If you need to update that `meta` hash
+  # at a later time, you can set a `ref_id`, which can be used to tell `#update`
+  # exactly which metric you want to update.  `ref_id`s have to be unique across
+  # `metric_name`s, and if you want to free up your `ref_id`s, you can set them to expire
+  # after a certain number of seconds with `editable_for`.
   # 
-  # `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
+  # ###Usage
+
+  #     DulyNoted.track("page_views",
+  #       for: "home",
+  #       meta: {browser: "chrome"})
+  # 
+  #     DulyNoted.track("video_plays",
+  #       for: ["user_7261", "video_917216"],
+  #       meta: {amount_watched: 0})
+  # 
+  #     DulyNoted.track("purchases",
+  #       for: "user_281",
+  #       generated_at: 1.day.ago,
+  #       ref_id: "pid_28172",
+  #       editable_for: 30)
     
   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
+    key = build_key(metric_name)
+    key << assemble_for(options)
+    DulyNoted.redis.pipelined do
+      DulyNoted.redis.sadd build_key("metrics"), build_key(metric_name)
+      DulyNoted.redis.zadd key, options[:generated_at].to_f, "#{key}:#{options[:generated_at].to_f}:meta"
+      DulyNoted.redis.set "#{build_key(metric_name)}:ref:#{options[:ref_id]}", "#{key}:#{options[:generated_at].to_f}:meta" if options[:ref_id] # set alias key
+      DulyNoted.redis.expire "#{build_key(metric_name)}:ref:#{options[:ref_id]}", options[:editable_for] if options[:editable_for]
+      if options[:meta] # set meta data
+        DulyNoted.redis.mapped_hmset "#{key}:#{options[:generated_at].to_f}:meta", options[:meta]
+        options[:meta].keys.each do |field|
+          DulyNoted.redis.sadd "#{key}:fields", field
+        end
+      end
+    end
   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`
+  #   ##Update
   # 
-  # `for`_(required if you set `for` when you generated the metric)_: A name space for your metric, ex: `home_page`
+  # _parameters: `metric_name`, `ref_id`, `meta`(optional), `editable_for`(optional)_
   # 
-  # `meta`_(optional)_: A hash with whatever meta data fields you might want to store, or update ex: `ip_address`, `file_type`, `time_left`
+  # Use update to add, or edit the metadata stored with a metric.  You can optionally set the `editable_for` option which will override any setting set by track.  So if it was set to expire in 30 seconds, and in 20 seconds you called update with `editable_for` set to `30`, it would be editable for 30 seconds from the moment you updated it.
   # 
   # ###Usage
   # 
+  #     DulyNoted.track("page_views",
+  #       ref_id: "a_unique_id",
+  #       meta: {time_on_page: 0, browser: "chrome"})
   #     DulyNoted.update("page_views",
   #       "a_unique_id",
-  #       for: "home_page",
-  #       meta: { time_on_page: 30 })
+  #       meta: { time_on_page: 30 },
+  #       editable_for: 30)
   
   def update(metric_name, ref_id, options={})
-    key = normalize(metric_name)
-    key << ":#{options[:for]}" if options[:for]
-    key << ":#{ref_id}"
+    key = build_key(metric_name)
+    key << ":ref:#{ref_id}"
     real_key = DulyNoted.redis.get key
+    raise InvalidRefId if real_key == nil
     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`
+  # _parameters: `metric_name`, `for`(optional), `meta_fields`(optional), `time_start`(optional), `time_end`(optional), `time_range`(optional)_
   # 
-  # `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.
+  # Query will return an array of all the metadata in chronological order from a time range, or for the whole data set.  If for is specified, it will limit it by that context.  For instance, if you have `track`ed several page views with `for` set to the name of the page that was viewed, you could query with `for` set to `home_page` to get all of the metadata from the page views from the home page, or you could leave off the `for`, and return all of the metadata for all of the page views, across all pages.
   # 
-  # `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
   # 
@@ -135,18 +166,13 @@ module DulyNoted
   #       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)
+    key = build_key(metric_name)
     parse_time_range(options)
-    key << ":#{options[:for]}" if options[:for]
+    key << assemble_for(options)
     if options[:ref_id]
-      key << ":#{options[:ref_id]}"
+      key << ":ref:#{options[:ref_id]}"
       real_key = DulyNoted.redis.get key
       if options[:meta_fields]
         options[:meta_fields].collect! { |x| x.to_s }
@@ -159,6 +185,7 @@ module DulyNoted
         results = [DulyNoted.redis.hgetall(real_key)]
       end
     else
+      keys = find_keys(key)
       grab_results = Proc.new do |metric|
         if options[:meta_fields]
           options[:meta_fields].collect! { |x| x.to_s }
@@ -171,10 +198,15 @@ module DulyNoted
           DulyNoted.redis.hgetall metric
         end
       end
+      results = []
       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)
+        keys.each do |key|
+          results += DulyNoted.redis.zrangebyscore(key, options[:time_start].to_f, options[:time_end].to_f).collect(&grab_results)
+        end
       else
-        results = DulyNoted.redis.zrange(key, 0, -1).collect(&grab_results)
+        keys.each do |key|
+          results += DulyNoted.redis.zrange(key, 0, -1).collect(&grab_results)
+        end
       end
     end
     return results
@@ -182,63 +214,144 @@ module DulyNoted
   
   # ##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`
+  # _parameters: `metric_name`, `for`(optional), `time_start`(optional), `time_end`(optional), `time_range`(optional)_
   # 
-  # `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`.
+  # Count will return the number of events logged in a given time range, or if no time range is given, the total count.  As with `#query`, you can specify `for` to return a subset of counts, or you can leave it off to get the count across the whole `metric_name`.
   # 
   # ###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)
+  #       time_start: 1.day.ago,
+  #       time_end: Time.now)
   
   def count(metric_name, options={})
     parse_time_range(options)
-    key = normalize(metric_name)
-    keys = []
-    if options[:for]
-      key << ":#{options[:for]}"
+    key = build_key(metric_name)
+    key << assemble_for(options)
+    keys = find_keys(key)
+    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 << DulyNoted.redis.keys("#{key}*")
-      keys - DulyNoted.redis.keys("#{key}*:meta")
-      keys - DulyNoted.redis.keys("#{key}:*:")
-      keys.flatten!
+      keys.each do |key|
+        sum += DulyNoted.redis.zcard(key)
+      end
+      return sum
     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
+
+  # ##Chart
+  # 
+  # _parameters: `metric_name`, `data_points`(required),`for`(optional), `time_start`(optional), `time_end`(optional), `time_range`(optional)_
+  # 
+  # Chart is a little complex, but I'll try to explain all of the possibilities.  It's main purpose is to pull out your data and prepare it in a way that makes it easy to chart.  The smallest amount of input it will take is just a `metric_name` and an amount of `data_points` to capture.  This will check the time of the earliest known data point, and the time of the last known data point, and run chart with those values as the `time_start` and `time_end` respectively.  It will take the amount of time that that spans, and divide it by the number of data points you asked for, and will split the time up evenly, and return a hash of times, and counts.  If you specify both a `time_start` and a `time_end`, and a number of `data_points`, then it will divide the amount of time that that spans and will return a hash of times and counts.  The other option is that you can specify either a `time_start` OR a `time_end` and a `step` and a number of `data_points`.  This will start at whatever time you specified, and (if it's `time_end`) count down by the step (if you specified `time_start`, it would count up), as many times as the number of data points you requested.
+  # 
+  # ###Usage
+  # 
+  #   DulyNoted.chart("page_views",
+  #     :time_range => 1.month.ago..Time.now,
+  #     :step => 1.day)
+  # 
+  #   DulyNoted.chart("page_views",
+  #     :time_range => 1.day.ago..Time.now,
+  #     :data_points => 12)
+  # 
+  #   DulyNoted.chart("page_views",
+  #     :time_start => 1.day.ago,
+  #     :step => 1.hour,
+  #     :data_points => 12)
+  # 
+  #   DulyNoted.chart("downloads",
+  #     :time_end => Time.now,
+  #     :step => 1.month,
+  #     :data_points => 12)
+  # 
+  #   DulyNoted.chart("page_views",
+  #     :data_points => 100)
+  # 
+  # 
+  # Chart can be a little confusing but it's pretty powerful, so play around with it.
+
+  def chart(metric_name, options={})
+    parse_time_range(options)
+    chart = Hash.new(0)
+    if options[:time_start] && options[:time_end]
+      time = options[:time_start]
+      if options[:data_points]
+        total_time = options[:time_end] - options[:time_start]
+        options[:step] = total_time.to_i / options[:data_points]
       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
+      while time < options[:time_end]
+        chart[time.to_i] = DulyNoted.count(metric_name, :time_start => time, :time_end => time+options[:step], :for => options[:for])
+        time += options[:step]
+      end
+    elsif options[:step] && options[:data_points] && (options[:time_end] || options[:time_start])
+      raise InvalidStep if options[:step] == 0
+      options[:step] *= -1 if (options[:step] > 0 && options[:time_end]) || (options[:step] < 0 && options[:time_start])
+      time = options[:time_start] || options[:time_end]
+      step = options[:step]
+      options[:data_points].times do
+        options[:time_start] = time
+        options[:time_start] += step if step < 0
+        options[:time_end] = time
+        options[:time_end] += step if step > 0
+        chart[time.to_i] = DulyNoted.count(metric_name, options)
+        time += step
       end
+    elsif options[:data_points]
+      key = build_key(metric_name)
+      key << assemble_for(options)
+      options[:time_start] = Time.at(DulyNoted.redis.zrange(key, 0, 0, :withscores => true)[1].to_f)
+      options[:time_end] = Time.at(DulyNoted.redis.zrevrange(key, 0, 0, :withscores => true)[1].to_f)
+      chart = DulyNoted.chart(metric_name, options)
+    else
+      raise InvalidOptions
+    end
+    return chart
+  end
+
+  # ##Magic
+  # 
+  # ###count_x_by_y
+  # 
+  # If you want to count a number of events by a meta field, you can use this magic command.  So imagine this scenario:
+  # 
+  #   DulyNoted.track("page_views", meta: {browser: "chrome"})
+  # 
+  # And you wanted to see a break down of page views by various browsers, you can call `DulyNoted.count_page_views_by_browser` and you'd get a hash that looked something like this:
+  # 
+  #   {"chrome" => 2913, "firefox" => 5281, "IE" => 7182, "safari" => 3213}
+  # 
+  # So that method will work as soon as you've tracked something with that metric name.  If you try to call the method on a metric that you haven't yet tracked you will get a `DulyNoted::NotValidMetric`.  But if you reference a meta field that didn't exist, you'd just get a hash that looks like
+  # 
+  #   {nil => 1}
+
+  def count_x_by_y(metric_name, meta_field, options)
+    options ||= {}
+    options = {:meta_fields => [meta_field]}.merge(options)
+    meta_hashes = query(metric_name, options)
+    result = Hash.new(0)
+    meta_hashes.each do |meta_hash|
+      result[meta_hash[meta_field]] += 1
+    end
+    result
+  end
+
+  # ##Behind the curtain (metaprogramming)
+  # 
+  # ###method_missing
+  # 
+  # As I'm sure you're aware, method_missing is the magic tool for ruby developers to define dynamic methods like the above `count_x_by_y`, which is exactly what we use it for.
+
+  def method_missing(method, *args, &block)
+    if method.to_s =~ /^count_(.+)_by_(.+)$/
+      count_x_by_y($1, $2, args[0])
+    else
+      super
     end
   end
   
@@ -258,13 +371,17 @@ module DulyNoted
     @redis ||= (
       url = URI(@redis_url || "redis://127.0.0.1:6379/0")
 
-      Redis.new({
+      check_schema(Redis.new({
         :host => url.host,
         :port => url.port,
         :db => url.path[1..-1],
         :password => url.password
-      })
+      }))
     )
   end
-
+  class NotValidMetric < StandardError; end
+  class InvalidOptions < StandardError; end
+  class InvalidStep < StandardError; end
+  class InvalidRefId < StandardError; end
+  class UpdateError < StandardError; end
 end

data/spec/duly_noted_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 describe DulyNoted do
   before :each do
     DulyNoted.redis.flushall
+    Timecop.return
   end
 
   describe "#track" do
@@ -16,14 +17,25 @@ describe DulyNoted do
       DulyNoted.count("page_views", :for => "home").should eq(2)
       DulyNoted.count("page_views", :for => "contact_us").should eq(5)
     end
+    it "can nest context" do
+      2.times { DulyNoted.track "views", :for => ["user_123", "video_8172"] }
+      2.times { DulyNoted.track "views", :for => ["user_123", "video_8173"] }
+      DulyNoted.count("views", :for => "user_123").should eq(4)
+      DulyNoted.count("views", :for => ["user_123", "video_8173"]).should eq(2)
+    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
+      Timecop.freeze
       DulyNoted.track "page_views", :generated_at => Time.now-10
       DulyNoted.count "page_views", :time_range => Time.now-11..Time.now-9
     end
+    it "will allow you to set expirations on `ref_id`s" do
+      DulyNoted.track "page_views", :meta => {:open => true}, :ref_id => "unique", :editable_for => 0
+      expect { DulyNoted.update("page_views", "unique") }.to raise_error(DulyNoted::InvalidRefId)
+    end
   end
 
   describe "#update" do
@@ -38,6 +50,11 @@ describe DulyNoted do
       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
+    it "does not require that `for:` be set to update" do
+      DulyNoted.track "page_views", :for => "home", :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"})
+    end
   end
 
   describe "#query" do
@@ -59,9 +76,13 @@ describe DulyNoted do
       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 grab only specific fields from a certain context from the hash" do
+      DulyNoted.track "page_views", :for => "home", :meta => {:seconds_open => 0, :browser => "chrome"}
+      DulyNoted.query("page_views", :for => "home", :meta_fields => [:browser]).should include({"browser" => "chrome"})
+    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
+      Timecop.freeze
+      5.times { DulyNoted.track "page_views", :meta => {:seconds_open => 5, :browser => "chrome"}, :generated_at => Time.now-1 }
       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"})
@@ -72,8 +93,7 @@ describe DulyNoted do
 
   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", :generated_at => Time.now-1 }
       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)
@@ -84,13 +104,95 @@ describe DulyNoted do
       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", :generated_at => Time.now-1 }
+      5.times { DulyNoted.track "page_views", :for => "contact_us", :generated_at => Time.now-1 }
       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
+
+  describe "#chart" do
+    it "should count by a specified time step and store the results in a hash" do
+      # Timecop.freeze
+      1.times { DulyNoted.track "page_views", :generated_at => Time.now-(2.9) }
+      2.times { DulyNoted.track "page_views", :generated_at => Time.now-(1.9) }
+      3.times { DulyNoted.track "page_views", :generated_at => Time.now-(0.9) }
+      DulyNoted.chart("page_views", :time_range => Time.now-(3)..Time.now-(1), :step => (1)).should have_at_least(3).items
+      DulyNoted.chart("page_views", :time_range => Time.now-(3)..Time.now-(1), :step => (1)).should eq({(Time.now-3).to_i => 1, (Time.now-2).to_i => 2, (Time.now-1).to_i => 3})
+    end
+    it "can count events between a time range, without a step set" do
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 12:30am")
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 1:20am")
+      DulyNoted.chart("page_views", :time_range => Chronic.parse("yesterday at 12am")...Chronic.parse("yesterday at 2am"), :data_points => 2).should eq({Chronic.parse("yesterday at 12am").to_i => 1, Chronic.parse("yesterday at 1am").to_i => 1})
+    end
+    it "will take time_start, step, and data_points options to build a chart" do
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 12:30am")
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 1:20am")
+      DulyNoted.chart("page_views", :time_start => Chronic.parse("yesterday at 12am"), :step => (3600), :data_points => 2).should eq({Chronic.parse("yesterday at 12am").to_i => 1, Chronic.parse("yesterday at 1am").to_i => 1})
+    end
+    it "will take time_end, step, and data_points options to build a chart" do
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 12:30am")
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 1:20am")
+      DulyNoted.chart("page_views", :time_end => Chronic.parse("yesterday at 2am"), :step => (3600), :data_points => 2).should eq({Chronic.parse("yesterday at 2am").to_i => 1, Chronic.parse("yesterday at 1am").to_i => 1})
+    end
+    it "should raise InvalidStep if you give it a step of zero" do
+      DulyNoted.track "page_views"
+      expect { DulyNoted.chart("page_views", :time_end => Time.now, :step => 0, :data_points => 2) }.to raise_error(DulyNoted::InvalidStep)
+    end
+    it "should raise InvalidOptions if you give it invalid options" do
+      DulyNoted.track "page_views"
+      expect { DulyNoted.chart("page_views", :time_end => Time.now, :step => 60*60) }.to raise_error(DulyNoted::InvalidOptions)
+    end
+    it "should chart everything if no time range is specified" do
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 12:30am")
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 1:20am")
+      DulyNoted.chart("page_views", :data_points => 2).should eq({Chronic.parse("yesterday at 12:30am").to_i => 1, Chronic.parse("yesterday at 12:55am").to_i => 1})
+    end
+  end
+
+  describe "#metrics" do
+    it "should list all currently tracking metrics" do
+      DulyNoted.track "page_views"
+      DulyNoted.metrics.should include("dn:pageviews")
+    end
+  end
+
+  describe "#valid_metric?" do
+    it "should determine if metric is valid" do
+      DulyNoted.track "page_views"
+      DulyNoted.valid_metric?("page_views").should be_true
+      DulyNoted.valid_metric?("kdfsjhfs").should be_false
+    end
+  end
+
+  describe "#fields_for" do
+    it "should list the stored meta fields for a given metric" do
+      DulyNoted.track "page_views", :for => "home", :meta => {:seconds_open => 5, :browser => "chrome"}
+      DulyNoted.fields_for("page_views").should include("seconds_open", "browser")
+    end
+  end
+
+  describe "#count_x_by_y" do
+    it "should count x by y" do
+      5.times { DulyNoted.track "page_views", :for => "home", :meta => {:browser => "chrome"} }
+      5.times { DulyNoted.track "page_views", :for => "contact_us", :meta => {:browser => "firefox"} }
+      DulyNoted.count_page_views_by_browser.should eq({"chrome" => 5, "firefox" => 5})
+      DulyNoted.count_page_views_by_browser(:for => "home").should eq({"chrome" => 5})
+    end
+    it "should raise NotValidMetric if the metric is not valid" do
+      DulyNoted.track "page_views", :meta => {:browser => "chrome"}
+      expect { DulyNoted.count_downloads_by_browser }.to raise_error(DulyNoted::NotValidMetric)
+    end
+  end
+
+  describe "#check_schema" do
+    it "should update the database if the schema is off by a major release" do
+      DulyNoted::VERSION = "2.0.0"
+      DulyNoted.redis = nil # Force a reset of the redis instance variable
+      DulyNoted.track "page_views"
+      DulyNoted.redis.get("dn:version").should eq("2.0.0")
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -7,4 +7,5 @@ unless Kernel.respond_to?(:require_relative)
 end
 
 require_relative "../lib/duly_noted"
-require 'chronic'
+require 'chronic'
+require 'timecop'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duly_noted
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-06 00:00:00.000000000 Z
+date: 2012-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &70245889112380 !ruby/object:Gem::Requirement
+  requirement: &70176012443720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70245889112380
+  version_requirements: *70176012443720
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70245889111680 !ruby/object:Gem::Requirement
+  requirement: &70176012459660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70245889111680
+  version_requirements: *70176012459660
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70245889110680 !ruby/object:Gem::Requirement
+  requirement: &70176012459240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70245889110680
+  version_requirements: *70176012459240
 - !ruby/object:Gem::Dependency
   name: rb-fsevent
-  requirement: &70245889109440 !ruby/object:Gem::Requirement
+  requirement: &70176012458820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70245889109440
+  version_requirements: *70176012458820
 - !ruby/object:Gem::Dependency
   name: guard-rspec
-  requirement: &70245889108340 !ruby/object:Gem::Requirement
+  requirement: &70176012458400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70245889108340
+  version_requirements: *70176012458400
 - !ruby/object:Gem::Dependency
-  name: growl
-  requirement: &70245889107640 !ruby/object:Gem::Requirement
+  name: guard-bundler
+  requirement: &70176012457980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70245889107640
+  version_requirements: *70176012457980
 - !ruby/object:Gem::Dependency
-  name: guard-bundler
-  requirement: &70245889106880 !ruby/object:Gem::Requirement
+  name: chronic
+  requirement: &70176012457560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +87,21 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70245889106880
+  version_requirements: *70176012457560
 - !ruby/object:Gem::Dependency
-  name: chronic
-  requirement: &70245889106080 !ruby/object:Gem::Requirement
+  name: timecop
+  requirement: &70176012457140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70176012457140
+- !ruby/object:Gem::Dependency
+  name: ruby_gntp
+  requirement: &70176012456720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,8 +109,8 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70245889106080
-description: keep detailed metrics on your project with a speedy, powerful redis backend.
+  version_requirements: *70176012456720
+description: a simple redis based stat-tracker
 email:
 - will@willcosgrove.com
 executables: []
@@ -117,6 +128,7 @@ files:
 - duly_noted.gemspec
 - lib/duly_noted.rb
 - lib/duly_noted/helpers.rb
+- lib/duly_noted/updater.rb
 - lib/duly_noted/version.rb
 - spec/duly_noted_spec.rb
 - spec/spec_helper.rb
@@ -132,18 +144,24 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 2593334725054151131
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 2593334725054151131
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.16
 signing_key: 
 specification_version: 3
-summary: a simple redis based stat-tracker
+summary: keep detailed metrics on your project with a speedy, powerful redis backend.
 test_files:
 - spec/duly_noted_spec.rb
 - spec/spec_helper.rb