rhcf-timeseries 0.0.6 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9cef009b581b2e4025db5234bc0ba24cb970503d
-  data.tar.gz: 5168fbcf5b232d4bc3e2687be9b57e4efd6a1cca
+  metadata.gz: 6ac0f81efa0f044a261c6919b0107b48e68efe24
+  data.tar.gz: 9e4248aec431ffb9c0f8dc07817c4af1189ba458
 SHA512:
-  metadata.gz: 2954a59ea1374b1308483c17480463ce3c3e9fc8c34881d9da4aae2728101f50ae44a666b41c0fe424c9475169fb872cf318cad1a771b2c72698fede5943141d
-  data.tar.gz: 6efdacb63cbc3f5f75a9b6568af314ba86f71b0555037daa36f673032de7480b023d3de7a50a1208911c43c9e510e63944d60ee2a281858fe8cd6f939bd7e91a
+  metadata.gz: 15e810d8f9f5b309f4fe92fcd0cc38a18d9ec3522ac85c00eb8f546113fd17cd23d5074fcaec349f49ae0699adb3e5cdede6c7ceff7b583844a25015a46dabaa
+  data.tar.gz: d3781b3ab20ef7f918d5f74353b37023323a7b4253b15b52d695efe2f2df50615aeaae8672c07cb3f9eab374ccb5408f56e2f57836695073d642733c4e3199d3

data/lib/rhcf/extensions/fixnum.rb

@@ -0,0 +1,34 @@
+class Fixnum
+  def minutes
+    self * 60
+  end
+
+  def hours
+    self.minutes * 60
+  end
+
+  def days
+    self.hours * 24
+  end
+
+  def seconds
+    self
+  end
+
+  def weeks
+    self.days * 7
+  end
+
+  def years
+    self.days * 365
+  end
+
+  alias_method :day, :days
+  alias_method :week, :weeks
+  alias_method :hour, :hours
+  alias_method :second, :seconds
+  alias_method :minute, :minutes
+  alias_method :year, :years
+end
+
+

data/lib/rhcf/timeseries/constants.rb

@@ -0,0 +1,25 @@
+module Rhcf
+  module Timeseries
+    EVENT_SET_TOKEN   = 'ES'
+    EVENT_POINT_TOKEN = 'P'
+    DEFAULT_PREFIX    = 'TS'
+
+    DEFAULT_RESOLUTIONS_MAP={
+      :ever => {span:Float::INFINITY, formatter: "ever", ttl: (2 * 366).days},
+      :year => {span: 365.days,formatter: "%Y", ttl: (2 * 366).days},
+      :week => {span: 1.week, formatter: "%Y-CW%w", ttl: 90.days},
+      :month => {span: 30.days, formatter: "%Y-%m", ttl: 366.days},
+      :day => {span: 1.day, formatter: "%Y-%m-%d", ttl: 30.days},
+      :hour => {span: 1.hour, formatter: "%Y-%m-%dT%H", ttl: 24.hours},
+      :minute => {span: 1.minute, formatter: "%Y-%m-%dT%H:%M", ttl: 120.minutes},
+      :second => {span: 1, formatter: "%Y-%m-%dT%H:%M:%S", ttl: 1.hour},
+      :"5seconds" => {span: 5.seconds, formatter: ->(time){ [time.strftime("%Y-%m-%dT%H:%M:") ,  time.to_i % 60/5, '*',5].join('') }, ttl: 1.hour},
+      :"5minutes" => {span: 5.minutes, formatter: ->(time){ [time.strftime("%Y-%m-%dT%H:") ,  (time.to_i/60) % 60/5, '*',5].join('') }, ttl: 3.hour},
+      :"15minutes" => {span: 15.minutes, formatter: ->(time){ [time.strftime("%Y-%m-%dT%H:") ,  (time.to_i/60) % 60/15, '*',15].join('') }, ttl: 24.hours}
+
+    }
+
+    DEFAULT_RESOLUTIONS = DEFAULT_RESOLUTIONS_MAP.keys
+    NAMESPACE_SEPARATOR = '|'
+  end
+end

data/lib/rhcf/timeseries/manager.rb

@@ -0,0 +1,119 @@
+unless 1.respond_to?(:minute)
+  require_relative '../extensions/fixnum'
+end
+require 'rhcf/timeseries/constants'
+require 'rhcf/timeseries/query'
+require 'rhcf/timeseries/redis_strategies'
+
+module Rhcf
+  module Timeseries
+
+    class Filter
+      attr_reader :regex
+      def initialize(keys, values)
+        @keys   = keys
+        @values = values
+      end
+
+      def regex
+        @regex ||= Regexp.new('\A' + @keys.map{|key| @values[key]|| '.*'}.join('\/') + '\z')
+      end
+
+      def match?(value)
+        value =~ regex
+      end
+
+      def to_lua_pattern
+        @lua_pattern ||= @keys.map{|key| @values[key]|| '.*'}.join('/')
+      end
+    end
+
+    class Manager
+      DEFAULT_STRATEGY  = RedisHgetallStrategy
+      attr_reader :prefix
+      def initialize(options = {})
+        @strategy          = ( options[:strategy]    || DEFAULT_STRATEGY).new
+        @resolution_ids    =   options[:resolutions] || DEFAULT_RESOLUTIONS
+        @prefix            = [(options[:prefix]      || DEFAULT_PREFIX) , @strategy.id].join(NAMESPACE_SEPARATOR)
+        @connection_to_use =   options[:connection]
+      end
+
+      def on_connection(conn)
+        old_connection = @connection_to_use
+        @connection_to_use = conn
+        yield self
+        @connection_to_use = old_connection
+      end
+
+      def connection_to_use
+        @connection_to_use || fail("No connection given")
+      end
+
+      def store(subject, event_point_hash, moment = Time.now, descend_subject = true, descend_event = true)
+        resolutions = resolutions_of(moment)
+
+        descend(subject, descend_subject) do |subject_path|
+          event_point_hash.each do |event, point_value|
+            descend(event, descend_event) do |event_path|
+              resolutions.each do |res|
+                resolution_name, resolution_value = *res
+                store_point_value(subject_path, resolution_name, resolution_value, point_value, event_path)
+              end
+            end
+          end
+        end
+      end
+
+      def resolutions_of(moment)
+        @resolution_ids.collect do |res_id|
+          [res_id, resolution_value_at(moment, res_id)]
+        end
+      end
+
+      def resolution_value_at(moment, res_id)
+        res_config = DEFAULT_RESOLUTIONS_MAP[res_id] # TODO configurable
+        if res_config.nil?
+          fail "No resolution config for id: #{res_id.class}:#{res_id}"
+        end
+
+        time_resolution_formater = res_config[:formatter]
+        case time_resolution_formater
+        when String
+          moment.strftime(time_resolution_formater)
+        when Proc
+          time_resolution_formater.call(moment)
+        else
+          fail ArgumentError, "Unexpected moment formater type #{time_resolution_formater.class}"
+        end
+      end
+
+      def descend(path, do_descend = true , &block)
+        return if path.empty? or path == "."
+        block.call(path)
+        descend(File.dirname(path), do_descend, &block) if do_descend
+      end
+
+      def store_point_value( subject_path, resolution_name, resolution_value, point_value, event_path)
+        @strategy.store_point_value(self, subject_path, resolution_name, resolution_value, point_value, event_path)
+      end
+
+      def find(subject, from, to = Time.now, filter = nil)
+        Rhcf::Timeseries::Query.new(subject, from, to, self, filter)
+      end
+
+      def resolution(id)
+        res = DEFAULT_RESOLUTIONS_MAP[id] # TODO configurable
+        fail ArgumentError, "Invalid resolution name #{id} for this time series" if res.nil?
+        res.merge(:id => id)
+      end
+
+      def resolutions
+        @_resolutions ||= @resolution_ids.map { |id| resolution(id) }
+      end
+
+      def crunch_values(subject, resolution_id, point, filter)
+        @strategy.crunch_values(self, subject, resolution_id, point, filter)
+      end
+    end
+  end
+end

data/lib/rhcf/timeseries/query.rb

@@ -0,0 +1,69 @@
+module Rhcf
+  module Timeseries
+    class Query
+      def initialize(subject, from, to, series, filter = nil)
+        fail ArgumentError, "Argument 'from' can not be bigger then 'to'" if from > to
+        @series = series
+        @subject = subject
+        @from = from
+        @to = to
+
+        @filter = filter
+      end
+
+      def total(resolution_id=nil)
+        accumulator={}
+        points(resolution_id || better_resolution[:id]) do |data|
+
+          data[:values].each do |key, value|
+            accumulator[key]||=0
+            accumulator[key]+=value
+          end
+        end
+        accumulator
+      end
+
+      def points(resolution_id)
+        list =[]
+
+        point_range(resolution_id) do |point|
+
+          values = @series.crunch_values(@subject, resolution_id, point, @filter)
+
+          next if values.empty?
+          data =  {moment: point, values: values }
+          if block_given?
+            yield data
+          else
+            list << data
+          end
+        end
+        list unless block_given?
+      end
+
+      def point_range(resolution_id)
+        resolution = @series.resolution(resolution_id)
+        span = resolution[:span]
+        ptr = @from.dup
+        while ptr < @to
+          point = @series.resolution_value_at(ptr, resolution_id)
+          yield point
+          ptr += span.to_i
+        end
+      rescue FloatDomainError
+        # OK
+      end
+
+      def better_resolution
+        span = @to.to_time - @from.to_time
+
+        resolutions = @series.resolutions.sort_by{|h| h[:span]}.reverse
+        5.downto(1) do |div|
+          res = resolutions.find{|r| r[:span] < span / div }
+          return res if res
+        end
+        return nil
+      end
+    end
+  end
+end

data/lib/rhcf/timeseries/redis_strategies.rb

@@ -0,0 +1,175 @@
+module Rhcf
+  module Timeseries
+    class RedisHgetallStrategy
+      def id
+        'H'
+      end
+
+      def crunch_values(manager, subject, resolution_id, point, filter)
+        values = hgetall(manager, EVENT_POINT_TOKEN, subject, resolution_id, point)
+        values.reject!{|event, value| !filter.match?(event) } if filter
+        values
+      end
+
+      def store_point_value(manager, subject_path, resolution_name, resolution_value, point_value, event_path)
+        key = [manager.prefix, EVENT_POINT_TOKEN ,subject_path, resolution_name, resolution_value].join(NAMESPACE_SEPARATOR)
+        manager.connection_to_use.hincrby(key, event_path, point_value)
+        manager.connection_to_use.expire(key, DEFAULT_RESOLUTIONS_MAP[resolution_name][:ttl])
+      end
+
+      def hgetall(manager, k,s,r,p)
+        key  = [ manager.prefix, k,s,r,p].join(NAMESPACE_SEPARATOR)
+        manager.connection_to_use.hgetall(key).each_with_object({}) do |(_k, value), hash|
+          hash[_k] = value.to_i
+        end
+      end
+    end
+
+    class RedisStringBasedStrategy
+      def id
+        fail 'AbstractStrategy'
+      end
+
+      def store_point_value(manager, subject_path, resolution_name, resolution_value, point_value, event_path)
+        store_point_event(manager, resolution_name, resolution_value, subject_path, event_path)
+        key = [manager.prefix, EVENT_POINT_TOKEN ,subject_path, resolution_name, resolution_value, event_path].join(NAMESPACE_SEPARATOR)
+        manager.connection_to_use.incrby(key, point_value)
+        manager.connection_to_use.expire(key, DEFAULT_RESOLUTIONS_MAP[resolution_name][:ttl])
+      end
+
+      def store_point_event(manager, resolution_name, resolution_value, subject_path, event_path)
+        key = [manager.prefix, EVENT_SET_TOKEN, resolution_name, resolution_value, subject_path].join(NAMESPACE_SEPARATOR)
+        manager.connection_to_use.sadd(key, event_path)
+        manager.connection_to_use.expire(key, DEFAULT_RESOLUTIONS_MAP[resolution_name][:ttl])
+      end
+
+      def events_for_subject_on(manager, subject, point, resolution_id, filter)
+        key = [manager.prefix, EVENT_SET_TOKEN, resolution_id, point, subject].join(NAMESPACE_SEPARATOR)
+        events = manager.connection_to_use.smembers(key)
+        events = events.select{|event| filter.match?(event) } if filter
+        events
+      end
+    end
+
+    class RedisMgetStrategy < RedisStringBasedStrategy
+      def id
+        'M'
+      end
+
+      def crunch_values(manager, subject, resolution_id, point, filter)
+        events = events_for_subject_on(manager, subject, point, resolution_id, filter)
+        mget(manager, EVENT_POINT_TOKEN, subject, resolution_id, point, events)
+      end
+
+      def mget(manager, k, s, r, p, es)
+        return {} if es.empty?
+        keys = es.map{|e| [manager.prefix, k, s, r, p, e].flatten.join(NAMESPACE_SEPARATOR)}
+        values = manager.connection_to_use.mget(*keys)
+        data = {}
+        keys.each_with_index do |key, index|
+          data[es[index]] = values[index].to_i
+        end
+        data
+      end
+    end
+
+    class RedisMgetLuaStrategy < RedisMgetStrategy
+      def id; 'ME'; end
+
+      def events_for_subject_on(manager, subject, point, resolution_id, filter)
+        key = [manager.prefix, EVENT_SET_TOKEN, resolution_id, point, subject].join(NAMESPACE_SEPARATOR)
+        events = if filter
+                   manager.connection_to_use.evalsha(evalsha_for(:smembers_matching),
+                                                     keys: [key], argv: [filter.to_lua_pattern])
+                 else
+                   manager.connection_to_use.smembers(key)
+                 end
+        events
+      end
+
+      def crunch_values(manager, subject, resolution_id, point, filter)
+        register_lua_scripts!(manager.connection_to_use)
+        point_prefix = [manager.prefix, EVENT_POINT_TOKEN, subject, resolution_id, point].join(NAMESPACE_SEPARATOR)
+        set_key = [manager.prefix, EVENT_SET_TOKEN, resolution_id, point, subject].join(NAMESPACE_SEPARATOR)
+
+        data = manager.connection_to_use.evalsha(evalsha_for(:mget_matching_smembers),
+                                                 keys: [set_key], argv: [point_prefix, filter && filter.to_lua_pattern])
+
+        return {} if data.nil?
+        result = {}
+        data.first.each_with_index do |evt, idx|
+          value = data.last[idx].to_i
+          result[evt] = value
+        end
+
+        result
+      end
+
+      def evalsha_for(sym_os_lua_script)
+        @lua_script_register[sym_os_lua_script] || fail("Script for '#{sym_os_lua_script}' not registered")
+      end
+
+      def register_lua_scripts!(connection)
+        @lua_script_register ||=
+          begin
+            smembers_matching = <<-EOF
+              local matches = {}
+              for _, val in ipairs(redis.call('smembers', KEYS[1])) do
+                if string.match(val, ARGV[1]) then
+                  table.insert(matches, val)
+                end
+              end
+              return matches
+            EOF
+
+            mget_matching_smembers = <<-EOF
+              local matches = {}
+              local set_key = KEYS[1]
+              local key_prefix = ARGV[1]
+              local filter_pattern = ARGV[2]
+              local keys = {}
+              local keys_to_mget = {}
+
+              for _, val in ipairs(redis.call('smembers', set_key)) do
+                if (filter_pattern and string.match(val, filter_pattern)) or not filter_pattern then
+                  table.insert(keys, val)
+                  table.insert(keys_to_mget, key_prefix .. '#{NAMESPACE_SEPARATOR}' .. val)
+                end
+              end
+
+              if table.getn(keys) > 0 then
+                return {keys, redis.call('MGET', unpack(keys_to_mget)) }
+              end
+              return {{},{}}
+            EOF
+
+            {
+              mget_matching_smembers: connection.script(:load, mget_matching_smembers),
+              smembers_matching: connection.script(:load, smembers_matching)
+            }
+          end
+      end
+    end
+
+    class RedisGetStrategy < RedisStringBasedStrategy
+      def id
+        'G'
+      end
+
+      def crunch_values(manager, subject, resolution_id, point, filter)
+        events = events_for_subject_on(manager, subject, point, resolution_id, filter)
+        values = {}
+        events.each do |event|
+          value = get(manager, EVENT_POINT_TOKEN, subject, resolution_id, point, event)
+          values[event] = value.to_i
+        end
+        values
+      end
+
+      def get(manager, *a_key)
+        a_key = [manager.prefix, a_key].flatten.join(NAMESPACE_SEPARATOR)
+        manager.connection_to_use.get(a_key)
+      end
+    end
+  end
+end

data/lib/rhcf/timeseries/version.rb

@@ -1,5 +1,5 @@
 module Rhcf
   module Timeseries
-    VERSION = "0.0.6"
+    VERSION = "1.0.0"
   end
 end

data/rhcf-timeseries.gemspec

@@ -25,8 +25,8 @@ Gem::Specification.new do |spec|
   #spec.add_development_dependency "guard"
   #spec.add_development_dependency "guard-rspec"
   #spec.add_development_dependency "guard-bundler"
-  #spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov"
   spec.add_development_dependency "timecop"
   spec.add_development_dependency "stackprof"
-  #spec.add_dependency "activesupport"
+  spec.add_development_dependency "database_cleaner"
 end

data/spec/lib/rhcf/timeseries/manager_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+require 'timecop'
+require 'redis'
+require 'rhcf/timeseries/manager'
+require 'benchmark'
+require 'stackprof'
+
+describe Rhcf::Timeseries::Manager do
+  let(:redis){Redis.new}
+  subject{Rhcf::Timeseries::Manager.new(connection: redis)}
+
+  before(:each) do
+    Timecop.return
+  end
+
+  describe 'descending' do
+    it "is fast to store and read" do
+      total = 0
+      start_time = Time.now
+
+      bench = Benchmark.measure {
+        StackProf.run(mode: :cpu, out: p('/tmp/stackprof-cpu-store-descend.dump')) do
+          1000.times do
+            total +=1
+            subject.store("a/b", {"e/f" => 1} ) #, time)
+          end
+        end
+      }
+
+
+      Benchmark.measure {
+        expect(subject.find("a", start_time - 11100, Time.now + 11100).total['e'].to_i).to eq(total)
+      }
+
+      Benchmark.measure {
+        expect(subject.find("a", start_time - 100000, Time.now + 100000).total(:year)['e/f'].to_i).to eq(total)
+      }
+
+      puts "Descend write speed %d points/seg | points:%d, duration:%0.3fs" % [speed = (1.0 * total / (bench.total + 0.00000001)), total, bench.total]
+      expect(speed).to be > 100
+    end
+  end
+
+  describe 'not descending' do
+    it "is be fast to store and read" do
+      total = 0
+      bench = Benchmark.measure {
+        StackProf.run(mode: :cpu, out: p('/tmp/stackprof-cpu-store-nodescend.dump')) do
+          1000.times do
+            total +=1
+            subject.store("a/b/c/d", {"e/f/g/h" => 1}  , Time.now, false, false)
+          end
+        end
+      }
+
+      puts "No descend write speed %d points/seg | points:%d, duration:%0.3fs" % [new_speed = (1.0 * total / (bench.total + 0.00000001)), total, bench.total]
+      expect(new_speed).to be > 300
+    end
+  end
+
+  describe "find and total" do
+    let(:start_time){  Time.parse("2000-01-01 00:00:00") }
+    before do
+      Timecop.travel(start_time)
+      subject.store("views/product/15", {"web/firefox/3" => 1})
+
+      Timecop.travel(15.minutes) #00:00:15
+      subject.store("views/product/13", {"web/firefox/3" => 1}, Time.now)
+      subject.store("views/product/13", {"web/firefox/3" => 1}, Time.now)
+      subject.store("views/product/13", {"web/firefox/3" => 0}, Time.now)
+
+      Timecop.travel(15.minutes) #00:00:30
+      subject.store("views/product/15", {"web/ie/6" => 3})
+
+      Timecop.travel(15.minutes) #00:00:45
+      subject.store("views/product/15", {"web/ie/6" => 2})
+
+      Timecop.travel(15.minutes) #00:00:00
+      subject.store("views/product/11", {"web/ie/5" => 2})
+
+      Timecop.travel(15.minutes) #00:00:15
+      subject.store("views/product/11", {"web/chrome/11"=> 4})
+
+      Timecop.travel(15.minutes) #00:00:30
+      subject.store("views/product/11", {"web/chrome/11"=> 2})
+    end
+
+    it "is similar to redistat" do
+
+      expect(subject.find("views/product", start_time, start_time + 55.minutes).total(:ever)).to  eq({
+        "web" => 16.0,
+        "web/chrome" => 6.0,
+        "web/chrome/11" => 6.0,
+        "web/firefox" => 3.0,
+        "web/firefox/3" => 3.0,
+        "web/ie" => 7.0,
+        "web/ie/5" => 2.0,
+        "web/ie/6" => 5.0
+      })
+
+      expect(subject.find("views/product", start_time, start_time + 55.minutes).total(:year)).to eq({
+        "web" => 16.0,
+        "web/chrome" => 6.0,
+        "web/chrome/11" => 6.0,
+        "web/firefox" => 3.0,
+        "web/firefox/3" => 3.0,
+        "web/ie" => 7.0,
+        "web/ie/5" => 2.0,
+        "web/ie/6" => 5.0
+      })
+
+      expect( subject.find("views/product", start_time, start_time + 55.minutes).total ).to eq({
+        'web' => 8,
+        'web/firefox' => 3,
+        'web/firefox/3' => 3,
+        'web/ie' => 5,
+        'web/ie/6' => 5,
+      })
+
+      expect(subject.find("views/product/15", start_time, start_time + 55.minutes).points(:minute)).to eq([
+        {:moment=>"2000-01-01T00:00", :values=>{"web/firefox"=>1, "web/firefox/3"=>1, "web"=>1}},
+        {:moment=>"2000-01-01T00:30", :values=>{"web"=>3, "web/ie/6"=>3, "web/ie"=>3}},
+        {:moment=>"2000-01-01T00:45", :values=>{"web"=>2, "web/ie/6"=>2, "web/ie"=>2}}
+      ])
+
+      expect(subject.find("views/product/13", start_time, start_time + 55.minutes).points(:minute)).to eq([
+        {:moment=>"2000-01-01T00:15", :values=>{"web/firefox"=>2, "web/firefox/3"=>2, "web"=>2}},
+      ])
+
+      expect(subject.find("views/product", start_time, start_time + 55.minutes).points(:minute)).to eq([
+        {:moment=>"2000-01-01T00:00", :values=>{"web/firefox"=>1, "web/firefox/3"=>1, "web"=>1}},
+        {:moment=>"2000-01-01T00:15", :values=>{"web/firefox"=>2, "web/firefox/3"=>2, "web"=>2}},
+        {:moment=>"2000-01-01T00:30", :values=>{"web"=>3, "web/ie/6"=>3, "web/ie"=>3}},
+        {:moment=>"2000-01-01T00:45", :values=>{"web"=>2, "web/ie/6"=>2, "web/ie"=>2}}
+      ])
+
+      expect(subject.find("views", start_time, start_time + 55.minutes).points(:minute)).to eq([
+        {:moment=>"2000-01-01T00:00", :values=>{"web/firefox"=>1, "web/firefox/3"=>1, "web"=>1}},
+        {:moment=>"2000-01-01T00:15", :values=>{"web/firefox"=>2, "web/firefox/3"=>2, "web"=>2}},
+        {:moment=>"2000-01-01T00:30", :values=>{"web"=>3, "web/ie/6"=>3, "web/ie"=>3}},
+        {:moment=>"2000-01-01T00:45", :values=>{"web"=>2, "web/ie/6"=>2, "web/ie"=>2}}
+      ])
+
+      expect(subject.find("views", start_time).points(:hour)).to eq([
+        {
+          :moment=>"2000-01-01T00",
+          :values=> {
+            "web/ie"=>5.0,
+            "web"=>8.0,
+            "web/firefox"=>3.0,
+            "web/ie/6"=>5.0,
+            "web/firefox/3"=>3.0}
+        },{
+          :moment=>"2000-01-01T01",
+          :values=>{
+            "web/ie"=>2.0,
+            "web/chrome"=>6.0,
+            "web/chrome/11"=>6.0,
+            "web"=>8.0,
+            "web/ie/5"=>2.0
+          }
+        }
+      ])
+    end
+    let(:filter) { Rhcf::Timeseries::Filter.new([:source, :browser], browser: 'firefox.*' )}
+    it "can find with filter" do
+      expect(subject.find("views", start_time, start_time + 55.minutes, filter).points(:minute)).to eq([
+        {:moment=>"2000-01-01T00:00", :values=>{"web/firefox"=>1, "web/firefox/3"=>1}},
+        {:moment=>"2000-01-01T00:15", :values=>{"web/firefox"=>2, "web/firefox/3"=>2}},
+      ])
+    end
+  end
+
+  it "causes no stack overflow" do
+    params_hash = {
+      sender_domain: 'example.com',
+      realm: 'realm',
+      destination_domain: 'lvh.me',
+      mail_server: 'aserver',
+      bind_interface: '11.1.1.11'
+    }
+
+    {
+      'sender_domain' => '%{sender_domain}',
+      'realm_and_sender_domain' => '%{realm}/%{sender_domain}',
+      'mail_server_and_interface' => '%{mail_server}/%{bind_interface}',
+      'realm_and_destination_domain' => '%{realm}/%{destination_domain}',
+      'destination_domain' => '%{destination_domain}'
+    }.each do |known, unknown|
+      subject.store(known % params_hash, {[(unknown % params_hash),'sent'].join('/') => 1})
+    end
+  end
+end

data/spec/lib/rhcf/timeseries/{result_spec.rb → query_spec.rb}

@@ -1,28 +1,28 @@
 require 'spec_helper'
-require 'rhcf/timeseries/redis'
+require 'rhcf/timeseries/manager'
 
 
 describe "Query" do
   describe "#better_resolution" do
 
-let(:redis_connection){nil}
+    let(:redis){nil}
     describe "When having a smaller then 1/5 " do
-      let(:series) { Rhcf::Timeseries::Redis.new(nil, redis_connection, resolutions: [:hour, :"15minutes", :minute]) }
+      let(:series) { Rhcf::Timeseries::Manager.new(connection: redis, resolutions: [:hour, :"15minutes", :minute]) }
       it { expect(series.find('bla', Time.now - 3600, Time.now).better_resolution[:id]).to eq :minute }
     end
 
     describe "When having a smaller but greather then 1/5" do
-      let(:series) { Rhcf::Timeseries::Redis.new(nil, redis_connection,  resolutions: [:hour, :"15minutes"]) }
+      let(:series) { Rhcf::Timeseries::Manager.new(connection: redis,  resolutions: [:hour, :"15minutes"]) }
       it { expect(series.find('bla', Time.now - 3600, Time.now).better_resolution[:id]).to eq :"15minutes" }
     end
 
     describe "When having no smaller, only its size" do
-      let(:series) { Rhcf::Timeseries::Redis.new(nil, redis_connection,  resolutions: [:hour]) }
+      let(:series) { Rhcf::Timeseries::Manager.new(connection: redis,  resolutions: [:hour]) }
       it { expect(series.find('bla', DateTime.parse('2015-01-01 01:50:00'), DateTime.parse('2015-01-01 03:10:00')).better_resolution[:id]).to eq :hour }
     end
 
     describe "When having only bigger" do
-      let(:series) { Rhcf::Timeseries::Redis.new(nil, redis_connection,  resolutions: [:month]) }
+      let(:series) { Rhcf::Timeseries::Manager.new(connection: redis,  resolutions: [:month]) }
       it { expect(series.find('bla', DateTime.parse('2015-01-01 01:50:00'), DateTime.parse('2015-01-01 03:10:00')).better_resolution).to be_nil}
     end