flamingo 0.2.1 → 0.3.1

data/README.md

@@ -12,24 +12,10 @@ a try if you have the need.
 
 Dependencies
 ------------
-* redis
-* resque
-* sinatra
-* twitter-stream
-* yajl-ruby
-* active_support
-* redis-namespace
-
-By default, the `resque` gem installs the latest 2.x `redis` gem, so if
-you are using Redis 1.x, you may want to swap it out.
-
-    $ gem list | grep redis
-    redis (2.0.3)
-    $ gem remove redis --version=2.0.3 -V
-
-    $ gem install redis --version=1.0.7
-    $ gem list | grep redis
-    redis (1.0.7)
+Check flamingo.gemspec for all the requirements. Currently there are quite a 
+few dependencies and they are very specific. We plan to have fewer dependencies 
+and be more liberal with versions soon. Right now these gems and versions are 
+what is working well in production for us.
 
 Getting Started
 ---------------
@@ -118,8 +104,12 @@ commandline (see below)
    Two things should now happen:
    * The pent-up jobs from the EXAMPLE queue should spray across your console
    * The resque dashboard should show the queue being emptied as a result 
+   
+10. Interact with your running flamingod instance via the REST API (by default it is on port 4711)
 
-
+        $ curl http://0.0.0.0:4711/
+   
+   That will show you available resources. Also, take a look at `lib/web/server.rb` for more.
    
 Overview
 --------
@@ -157,8 +147,12 @@ code.
 
 TODO
 -----
-* OAuth instructions
-    
+* A proper REST API client
+* Remove resque dependency
+* More liberal gem dependencies
+ * Redis 2.x
+ * ActiveSupport 3.x
+* OAuth support
 
 Flamingo
 --------

data/examples/flamingo.yml

@@ -13,8 +13,11 @@ logging:
   level:        DEBUG
 
 # Where is the redis server the flamingod processes should connect to?
+# By default, all keys are namespaced wih "flamingo". May be changed 
+# to run multiple flamingods in the same redis DB.
 redis:
   host:         0.0.0.0:6379
+  namespace:    flamingo
 
 # What port and interface should the flamingod web_server listen on?
 # use 0.0.0.0 for all interfaces, 127.0.0.1 to listen on only localhost

data/lib/flamingo.rb

@@ -11,9 +11,8 @@ require 'sinatra/base'
 
 require 'flamingo/version'
 require 'flamingo/config'
-require 'flamingo/stats/time_series'
+require 'flamingo/meta'
 require 'flamingo/dispatch_event'
-require 'flamingo/dispatch_error'
 require 'flamingo/stream_params'
 require 'flamingo/stream'
 require 'flamingo/subscription'
@@ -28,47 +27,48 @@ require 'flamingo/daemon/flamingod'
 require 'flamingo/logging/formatter'
 require 'flamingo/web/server'
 
-
 module Flamingo
   
   class << self
     
-    def configure!(config_file=nil)
-      config_file = find_config_file(config_file)
-      @config = Flamingo::Config.load(config_file)
+    # Configures flamingo. This must be called prior to using any flamingo 
+    # classes. 
+    # 
+    # The config argument may be one of:
+    # 1) nil: Try to locate a config file in ./flamingo.yml, ~/flamingo.yml
+    # 2) String: A config file name (preferred)
+    # 3) Flamingo::Config: Used as the configuration directly
+    # 4) Hash: Converted to a Flamingo::Config and used as the configuration
+    def configure!(cfg_info=nil,validate=true)
+      if cfg_info.nil? || cfg_info.kind_of?(String)
+        config_file = find_config_file(cfg_info)
+        @config = Flamingo::Config.load(config_file)
+        logger.info "Loaded config file from #{config_file}"
+      elsif cfg_info.kind_of?(Flamingo::Config)
+        @config = cfg_info
+      elsif cfg_info.kind_of?(Hash)
+        @config = Flamingo::Config.new(cfg_info)
+      end
       validate_config!
-      logger.info "Loaded config file from #{config_file}"
-    end
-    
-    def config=(config)
-      @config = config 
+      # Ensure redis gets loaded
+      redis
     end
     
     def config
       @config
     end
     
-    # PHD: Lovingly borrowed from Resque
+    # PHD: Partially borrowed from resque
 
-    # Accepts:
-    #   1. A 'hostname:port' string
-    #   2. A 'hostname:port:db' string (to select the Redis db)
-    #   3. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
-    #      or `Redis::Namespace`.
+    # server must be a "hostname:port[:db]" string
     def redis=(server)
-      case server
-      when String
-        host, port, db = server.split(':')
-        redis = Redis.new(:host => host, :port => port,
-          :thread_safe => true, :db => db)
-        @redis = Redis::Namespace.new(:flamingo, :redis => redis)
-      when Redis, Redis::Client, Redis::DistRedis
-        @redis = Redis::Namespace.new(:flamingo, :redis => server)
-      when Redis::Namespace
-        @redis = server
-      else
-        raise "Invalid redis configuration: #{server.inspect}"
-      end
+      host, port, db = server.split(':')
+      redis = Redis.new(:host => host, :port => port,
+        :thread_safe => true, :db => db)
+      @redis = Redis::Namespace.new(namespace, :redis => redis)
+      
+      # Ensure resque is configured to use this redis as well
+      Resque.redis = server
     end
   
     # Returns the current Redis connection. If none has been created, will
@@ -79,28 +79,6 @@ module Flamingo
       self.redis
     end
 
-    def new_logger
-      # determine log file location (default is root_dir/log/flamingo.log)
-      if valid_logging_dest?(config.logging.dest(nil))
-        log_dest = config.logging.dest
-      else
-        log_dest = File.join(root_dir,'log','flamingo.log')
-      end
-
-      # determine logging level (default is Logger::INFO)
-      begin
-        log_level = Logger.const_get(config.logging.level.upcase)
-      rescue
-        log_level = Logger::INFO
-      end
-
-      # create logger facility
-      logger = Logger.new(log_dest)
-      logger.level = log_level
-      logger.formatter = Flamingo::Logging::Formatter.new
-      logger
-    end
-
     def logger
       @logger ||= new_logger
     end
@@ -109,7 +87,38 @@ module Flamingo
       @logger = logger
     end
     
+    def namespace
+      config.redis.namespace(:flamingo)
+    end
+    
+    def dispatch_queue
+      @dispatch_queue ||= "#{namespace}:dispatch"
+    end
+    
+    def meta
+      @meta ||= Flamingo::Meta.new(redis)
+    end
+    
+    # Intended to be called after a fork so that we don't have 
+    # issues with shared file descriptors, sockets, etc
+    def reconnect!
+      reconnect_redis_client(@redis)      
+      reconnect_redis_client(Resque.redis)
+      # Reload logger
+      logger.close
+      self.logger = new_logger
+    end
+    
     private
+      def reconnect_redis_client(client)
+        # Unfortunately older versions of the Redis client don't make these 
+        # methods public so we have to use send. Later versions have made 
+        # these public.
+        if client && (client.send(:connected?) rescue true)
+          client.send(:reconnect)
+        end
+      end
+      
       def root_dir
         File.expand_path(File.dirname(__FILE__)+'/..')
       end

data/lib/flamingo/daemon/child_process.rb

@@ -24,8 +24,16 @@ module Flamingo
       end
       
       def start
-        self.pid = fork { run }
-      end      
+        self.pid = fork do
+          post_fork
+          run
+        end
+      end
+      
+      private
+        def post_fork
+          Flamingo.reconnect!
+        end
     end
   end
 end

data/lib/flamingo/daemon/dispatcher_process.rb

@@ -2,7 +2,7 @@ module Flamingo
   module Daemon
     class DispatcherProcess < ChildProcess
       def run
-        worker = Resque::Worker.new(:flamingo)
+        worker = Resque::Worker.new(Flamingo.dispatch_queue)
         def worker.procline(value)
           # Hack to get around resque insisting on setting the proces name
           $0 = "flamingod-dispatcher"
@@ -10,6 +10,6 @@ module Flamingo
         Flamingo.logger.info "Starting dispatcher on pid=#{Process.pid} under pid=#{Process.ppid}"
         worker.work(1) # Wait 1s between jobs
       end
-    end    
+    end
   end
 end

data/lib/flamingo/daemon/flamingod.rb

@@ -143,17 +143,36 @@ module Flamingo
             io.reopen '/dev/null' rescue nil
           end
           run
+          clear_process_meta_data
           pid_file.delete
         end
         Process.detach(pid)
         pid
       end
+      
+      def set_process_meta_data
+        meta = Flamingo.meta
+        meta[:start_time] = Time.now.utc.to_i
+        meta[:host] = `hostname`.chomp rescue nil
+        meta[:pid] = Process.pid
+        meta[:running] = true
+      end
+      
+      def clear_process_meta_data
+        meta = Flamingo.meta
+        meta.delete(:start_time)
+        meta.delete(:host)
+        meta.delete(:pid)
+        meta[:running] = false
+      end
 
       def run
         $0 = 'flamingod'
+        set_process_meta_data
         trap_signals
         start_children
         wait_on_children
+        clear_process_meta_data
       end
     end
   end

data/lib/flamingo/dispatch_event.rb

@@ -1,10 +1,17 @@
 module Flamingo
   class DispatchEvent
 
-    @queue = :flamingo
     @parser = Yajl::Parser.new(:symbolize_keys => true)
 
     class << self
+      
+      def queue
+        Flamingo.dispatch_queue
+      end
+      
+      def meta
+        Flamingo.meta
+      end
 
       #
       # TODO Track stats including: tweets per second and last tweet time
@@ -15,10 +22,13 @@ module Flamingo
       #      dispatching to improve in-order delivery (helps with "k-sorted")
       #
       def perform(event_json)
+        meta.incr("events:all_count")
+        meta.set("events:last_time",Time.now.utc.to_i)
         type, event = typed_event(parse(event_json))
+        meta.incr("events:#{type}_count")
         Subscription.all.each do |sub|
           Resque::Job.create(sub.name, "HandleFlamingoEvent", type, event)
-          Flamingo.logger.debug "Put job on subscription queue #{sub.name} for #{event_json}"
+          Flamingo.logger.debug "Put job on subscription queue #{sub.name}\n#{event_json}"
         end
       end
 

data/lib/flamingo/meta.rb

@@ -0,0 +1,71 @@
+module Flamingo
+  
+  class Meta
+    
+    attr_accessor :redis
+    
+    def initialize(redis)
+      self.redis = redis
+    end
+    
+    def incr(name,amt=1)
+      redis.incrby(key(name),amt)      
+    end
+    
+    def set(name,value)
+      redis.set(key(name),value)
+    end
+    alias_method :[]=,:set
+    
+    def get(name)
+      norm_value(redis.get(key(name)))
+    end
+    alias_method :[],:get
+  
+    def delete(name)
+      redis.del(key(name))
+    end
+    
+    def all
+      redis.keys("#{namespace}*").map do |k|
+        [denamespace(k),norm_value(redis.get(k))]
+      end
+    end
+    
+    def clear
+      all.each do |key,value|
+        delete(key)
+      end
+    end
+    
+    def to_h
+      all.inject({}) do |hash, (key,value)|
+        hash[key] = value
+        hash
+      end
+    end
+  
+    private
+      def norm_value(value)
+        if value.kind_of?(String) && value =~ /^\d+$/ 
+          value.to_i
+        else
+          value
+        end
+      end
+      
+      def denamespace(key)
+        key.gsub(namespace,'')
+      end
+      
+      def namespace
+        "meta:"
+      end
+      
+      def key(name)
+        "#{namespace}#{name}"
+      end
+    
+  end
+  
+end

data/lib/flamingo/stream.rb

@@ -10,6 +10,12 @@ module Flamingo
       :retweet  => "statuses/retweet",
       :sample   => "statuses/sample"
     )
+    
+    DEFAULT_CONNECTION_OPTIONS = {
+      :method     =>"POST", 
+      :ssl        => false, 
+      :user_agent => "Flamingo/#{Flamingo::VERSION}"
+    }
 
     class << self
       def get(name)
@@ -25,13 +31,17 @@ module Flamingo
     end
     
     def connect(options)
-      conn_opts = {:ssl => false, :user_agent => "Flamingo/0.1" }.
-        merge(options).merge(:path=>path)
-      Twitter::JSONStream.connect(conn_opts)
+      Twitter::JSONStream.connect(connection_options(options))
+    end
+    
+    def connection_options(overrides={})
+      DEFAULT_CONNECTION_OPTIONS.
+        merge(overrides).
+        merge(:path=>path,:content=>query)      
     end
     
     def path
-      "/#{VERSION}/#{resource}.json?#{query}"
+      "/#{VERSION}/#{resource}.json"
     end
     
     def resource

data/lib/flamingo/version.rb

@@ -1,3 +1,3 @@
 module Flamingo
-  Version = VERSION = '0.2.1'
+  Version = VERSION = '0.3.1'
 end

data/lib/flamingo/wader.rb

@@ -141,7 +141,6 @@ module Flamingo
       end
       
       def dispatch_event(event_json)
-        Flamingo.logger.debug "Wader dispatched event"
         Resque.enqueue(Flamingo::DispatchEvent, event_json)
       end
 

data/lib/flamingo/web/server.rb

@@ -9,11 +9,15 @@ module Flamingo
       get '/' do
         content_type 'text/plain'
         api = self.methods.select do |method|
-          (method =~ /^(GET|POST) /) && !(method =~ /png$/)
+          (method =~ /^(GET|POST|PUT|DELETE) /) && !(method =~ /png$/)
         end
         api.sort.join("\n")
       end
       
+      get '/meta.json' do
+        to_json(Flamingo.meta.to_h)
+      end
+      
       get '/streams/:name.json' do
         stream = Stream.get(params[:name])
         to_json(

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: flamingo
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 17
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 1
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Hayes Davis
@@ -16,55 +16,63 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-25 00:00:00 -07:00
+date: 2010-11-26 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: redis
+  name: activesupport
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 25
+        hash: 11
         segments: 
+        - 2
         - 1
         - 0
-        - 7
-        version: 1.0.7
+        version: 2.1.0
+    - - <=
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 3
+        - 5
+        version: 2.3.5
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: redis-namespace
+  name: eventmachine
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - "="
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 59
         segments: 
         - 0
-        - 7
-        - 0
-        version: 0.7.0
+        - 12
+        - 10
+        version: 0.12.10
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: resque
+  name: rack
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - "="
       - !ruby/object:Gem::Version 
-        hash: 61
+        hash: 19
         segments: 
         - 1
-        - 9
-        - 7
-        version: 1.9.7
+        - 1
+        - 0
+        version: 1.1.0
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -81,60 +89,146 @@ dependencies:
         - 9
         - 2
         version: 0.9.2
+    - - <=
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
   type: :runtime
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: twitter-stream
+  name: redis
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 19
+        hash: 25
         segments: 
-        - 0
         - 1
-        - 4
-        version: 0.1.4
+        - 0
+        - 7
+        version: 1.0.7
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
   type: :runtime
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
-  name: yajl-ruby
+  name: redis-namespace
   prerelease: false
   requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - "="
       - !ruby/object:Gem::Version 
-        hash: 9
+        hash: 3
         segments: 
         - 0
-        - 6
         - 7
-        version: 0.6.7
+        - 0
+        version: 0.7.0
   type: :runtime
   version_requirements: *id006
 - !ruby/object:Gem::Dependency 
-  name: activesupport
+  name: resque
   prerelease: false
   requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 61
+        segments: 
+        - 1
+        - 9
+        - 7
+        version: 1.9.7
+  type: :runtime
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: twitter-stream
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 11
+        hash: 19
         segments: 
-        - 2
+        - 0
         - 1
+        - 4
+        version: 0.1.4
+    - - <=
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
         - 0
-        version: 2.1.0
+        - 1
+        - 6
+        version: 0.1.6
   type: :runtime
-  version_requirements: *id007
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 7
+        - 6
+        version: 0.7.6
+  type: :runtime
+  version_requirements: *id009
+- !ruby/object:Gem::Dependency 
+  name: SystemTimer
+  prerelease: false
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 2
+        version: "1.2"
+  type: :runtime
+  version_requirements: *id010
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id011 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 0
+        - 9
+        - 8
+        version: 0.9.8
+  type: :development
+  version_requirements: *id011
 - !ruby/object:Gem::Dependency 
   name: mockingbird
   prerelease: false
-  requirement: &id008 !ruby/object:Gem::Requirement 
+  requirement: &id012 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -146,8 +240,8 @@ dependencies:
         - 0
         version: 0.1.0
   type: :development
-  version_requirements: *id008
-description: "    Flamingo makes it easy to wade through the Twitter Streaming API by \n    handling all connectivity and resource management for you. You just tell \n    it what to track and consume the information in a resque queue. \n\n    Flamingo isn't a traditional ruby gem. You don't require it into your code.\n    Instead, it's designed to run as a daemon like redis or mysql. It provides \n    a REST interface to change the parameters sent to the Twitter Streaming \n    resource. All events from the streaming API are placed on a resque job \n    queue where your application can process them.\n\n"
+  version_requirements: *id012
+description: "    Flamingo makes it easy to wade through the Twitter Streaming API by \n    handling all connectivity and resource management for you. You just tell \n    it what to track and consume the information in a resque queue. \n\n    Flamingo isn't a traditional ruby gem. You don't require it into your code.\n    Instead, it's designed to run as a daemon like redis or mysql. It provides \n    a REST interface to change the parameters sent to the Twitter Streaming \n    resource. All events from the streaming API are placed on a resque job \n    queue where your application can process them.\n    \n    CAVEAT EMPTOR: This gem is alpha code so act accordingly.\n\n"
 email: hayes@appozite.com
 executables: 
 - flamingo
@@ -168,10 +262,9 @@ files:
 - lib/flamingo/daemon/trap_keeper.rb
 - lib/flamingo/daemon/wader_process.rb
 - lib/flamingo/daemon/web_server_process.rb
-- lib/flamingo/dispatch_error.rb
 - lib/flamingo/dispatch_event.rb
 - lib/flamingo/logging/formatter.rb
-- lib/flamingo/stats/time_series.rb
+- lib/flamingo/meta.rb
 - lib/flamingo/stream.rb
 - lib/flamingo/stream_params.rb
 - lib/flamingo/subscription.rb

data/lib/flamingo/dispatch_error.rb

@@ -1,11 +0,0 @@
-module Flamingo
-  class DispatchError
-    
-    @queue = :flamingo
-    
-    def self.perform(type,message,data)
-      Flamingo.logger.info("#{type}, #{message}, #{data.inspect}\n")
-    end
-    
-  end
-end

data/lib/flamingo/stats/time_series.rb

@@ -1,134 +0,0 @@
-module Flamingo
-  module Stats
-    class TimeSeries
-
-      attr_accessor :name, :seconds_per_tick, :total_ticks
-      
-      class << self
-        def create(name,seconds_per_tick,total_ticks)
-          redis.set("stats:#{name}:schema","#{seconds_per_tick},#{total_ticks}")
-          new(name,seconds_per_tick,total_ticks)
-        end
-
-        def get(name)
-          schema_value = redis.get("stats:#{name}:schema")
-          raise "No schema specified" unless schema_value
-          seconds_per_tick, total_ticks = schema_value.split(",").map{|v| v.to_i}
-          new(name,seconds_per_tick,total_ticks)
-        end
-
-        def redis
-          Flamingo.redis
-        end
-
-      end
-
-      def initialize(name,seconds_per_tick,total_ticks)
-        self.name = name
-        self.seconds_per_tick = seconds_per_tick
-        self.total_ticks = total_ticks
-      end
-
-      def data(ticks=total_ticks,time=Time.now.utc)
-        range = tick_range(ticks,time)
-        keys = range.map {|t| value_key(t) }
-        values = redis.mget(keys).map {|v| (v || 0).to_f }
-        range.map {|t| t * seconds_per_tick }.zip(values)
-      end
-      
-      def each_datum(ticks=total_ticks,time=Time.now.utc)
-        tick_range(ticks,time).each do |tick|
-          yield(tick*seconds_per_tick,value(tick))
-        end
-      end
-      
-      def tick_range(ticks=total_ticks,time=Time.now.utc)
-        end_tick = to_tick(time)
-        start_tick = (end_tick - ticks) + 1
-        (start_tick..end_tick)        
-      end
-      
-      def average(ticks=total_ticks,time=Time.now.utc)
-        count = 0
-        sum = 0
-        each_datum do |ts, value|
-          count += 1
-          sum += value
-        end
-        if count == 0
-          nil
-        else
-          sum / count
-        end
-      end
-
-      def increment(val=1,time=Time.now.utc)
-        modify_value_at(time) do |val_key|
-          redis.incrby(val_key,val)  
-        end
-      end
-
-      def set(val,time=Time.now.utc)
-        modify_value_at(time) do |val_key|
-          redis.set(val_key,val)
-        end
-      end
-      
-      private
-        def modify_value_at(time=Time.now.utc)
-          t = to_tick(time)
-          return false unless valid?(t)
-          val_key = value_key(t)
-          yield(val_key)
-          ver_key = version_key(t)
-          prev_tick = redis.getset(ver_key,t)
-          if prev_tick && prev_tick.to_i < t
-            redis.del(value_key(prev_tick.to_i))
-          end
-          true
-        end
-      
-        def value(tick)
-          val = redis.get(value_key(tick))
-          val ? val.to_f : 0
-        end
-        
-        def to_tick(time=Time.now.utc)
-          (time.to_i / seconds_per_tick)
-        end
-        
-        def now_tick
-          to_tick(Time.now.utc)
-        end
-        
-        def valid?(tick)
-          nt = now_tick
-          (nt - total_ticks) <= tick && tick <= nt
-        end
-        
-        def tick_series(tick)
-          tick / total_ticks
-        end
-        
-        def tick_pos(tick)
-          tick % total_ticks
-        end
-        
-        def value_key(tick)
-          s = tick_series(tick)
-          pos = tick_pos(tick)
-          "stats:#{name}:#{s}:#{pos}"
-        end
-      
-        def version_key(tick)
-          pos = tick_pos(tick)
-          "stats:#{name}:v:#{pos}"
-        end
-
-        def redis
-          self.class.redis
-        end      
-
-    end
-  end
-end