queris 0.8.1

data/data/redis_scripts/remove_from_sets.lua

@@ -0,0 +1,13 @@
+local keys = KEYS
+local id = ARGV[1]
+local removed = 0
+for i, key in ipairs(keys) do
+  local keytype = redis.call('type', key).ok
+  if keytype == 'set' then
+    removed = removed + redis.call('srem', key, id)
+  elseif keytype == 'zset' then
+    removed = removed + redis.call('zrem', key, id)
+  end
+end
+--redis.log(redis.LOG_NOTICE, "Queris deleted " .. removed .. " ids from " .. #keys .. " keys.")
+return removed

data/data/redis_scripts/results_from_hash.lua

@@ -0,0 +1,54 @@
+local results_key = KEYS[1]
+local command, min, max, hashkeyf, lim, offset, withscores, replace_keyf, replace_id_attr = ARGV[1], ARGV[2], ARGV[3], ARGV[4], ARGV[5], ARGV[6], ARGV[7], ARGV[8], ARGV[9]
+local ids, scores, ids_with_scores = {}, {}, {}
+
+if command == "smembers" then
+  ids = redis.call(command, results_key)
+elseif command == "zrangebyscore" or command == "zrevrangebyscore" then
+  local offset, lim = ARGV[5], ARGV[6]
+  if not lim or (type(lim)=='string' and #lim==0) then
+    ids_with_scores = redis.call(command, results_key, min, max, "withscores")
+  else
+    ids_with_scores = redis.call(command, results_key, min, max, "withscores", "LIMIT", offset, lim)
+  end
+else
+  ids_with_scores = redis.call(command, results_key, min, max, "withscores")
+end
+
+for i, v in ipairs(ids_with_scores) do
+  if i%2==1 then  
+    if replace_keyf and #replace_keyf > 0 then
+      --replace/join logic
+      local replacement_id = redis.call("hget", hashkeyf:format(v), replace_id_attr)
+      if not replacement_id then
+        redis.call("echo", "replacement_id is empty!...")
+      else
+        v=replacement_id
+      end
+    end
+    
+    table.insert(ids, v)
+  else
+    table.insert(scores, v)
+  end
+end
+
+if replace_keyf and #replace_keyf > 0 then
+  hashkeyf=replace_keyf
+end
+
+local ret, notfound = {}, {}
+for i,id in ipairs(ids) do
+  local flathash = redis.call("hgetall", hashkeyf:format(id))
+  if #flathash>0 then
+    if #withscores>0 then
+      table.insert(flathash, "____score")
+      table.insert(flathash, scores[i])
+    end
+    ret[i] = flathash
+  else --notfound
+    ret[i] = id
+    table.insert(notfound, i-1) --0-based index
+  end
+end
+return {ret, ids, notfound}

data/data/redis_scripts/results_with_ttl.lua

@@ -0,0 +1,20 @@
+local results_key = KEYS[1]
+local existence_keyf = ARGV[1]
+local keytype = redis.call('type', results_key).ok
+local ids
+if keytype == "set" then
+  redis.call("echo", "IS A SET")
+  ids = redis.call("smembers", results_key)
+elseif keytype == "zset" then
+  redis.call("echo", "IS A SORTED SET")
+  ids = redis.call("zrange", results_key, 0, -1)
+else
+  ids = {}
+end
+redis.call("echo", "FOUND " .. #ids .. " ids")
+local existing, expired = {}, {}
+for i,id in ipairs(ids) do
+  local exists = redis.call("exists", existence_keyf:format(id))
+  table.insert(exists and existing or expired, id)
+end
+return {existing, expired}

data/data/redis_scripts/subquery_intersect_optimization.lua

@@ -0,0 +1,25 @@
+local dstkey, srckey, smallkey = KEYS[1], KEYS[2], KEYS[3]
+local multiplier = tonumber(ARGV[1])
+local setsize=function(k)
+  local t = redis.call('type', k).ok
+  if t=='zset' then
+    return redis.call('zcard', k)
+  elseif t == 'set' then
+    return redis.call('scard', k)
+  else
+    return 0
+  end
+end
+local srcsize, smallsize = setsize(srckey), setsize(smallkey)
+redis.log(redis.LOG_WARNING, ("QWOPTIMIZE |%s| against |%s|. mult=%s. do it? %s"):format(srcsize, smallsize, multiplier, (smallsize * multiplier < srcsize) and 'yes' or 'no'))
+if smallsize * multiplier < srcsize then
+  redis.log(redis.LOG_WARNING, "serverside optimizing " .. dstkey)
+  redis.call('zinterstore', dstkey, 2, srckey, smallkey, 'weights', 1, 0)
+else
+  redis.log(redis.LOG_WARNING, "serverside nonoptimizing " .. dstkey)
+  redis.log(redis.LOG_WARNING, "moving "..srckey .." to "..dstkey)
+  
+  redis.call('rename', srckey, dstkey)
+  redis.log(redis.LOG_WARNING, "moved.")
+  redis.call('set', srckey, dstkey) -- temp state to be cleaned up later
+end

data/data/redis_scripts/subquery_intersect_optimization_cleanup.lua

@@ -0,0 +1,5 @@
+local querykey , tmpkey = KEYS[1], KEYS[2]
+if redis.call('type', querykey).ok =='string' and redis.call('get', querykey) == tmpkey then
+  redis.call('move', tmpkey, querykey)
+  redis.log(redis.LOG_WARNING, "moved subquery key back from " .. tmpkey .. " to " .. querykey)
+end

data/data/redis_scripts/undo_add_low_ttl.lua

@@ -0,0 +1,8 @@
+local undo_key = KEYS[1]
+local ttl_diff = tonumber(ARGV[1])
+for i,v in ipairs(redis.call('smembers', undo_key)) do
+  local ttl = tonumber(redis.call('ttl', k))
+  if ttl > 0 then
+    redis.call('expire', ttl + ttl_diff)
+  end
+end

data/data/redis_scripts/unpaged_query_ready.lua

@@ -0,0 +1,17 @@
+local results_key, exists_key, runstate_key = KEYS[1], KEYS[2], KEYS[3]
+redis.log(redis.LOG_WARNING, "unpaged_query_ready - " .. redis.call('exists', exists_key) .. "  " .. exists_key)
+
+if redis.call('exists', exists_key) ~= 1 then
+  redis.log(redis.LOG_WARNING, "exists is absent")
+  return nil
+end
+local t = redis.call('type', results_key).ok
+if t == 'string' then
+  redis.log(redis.LOG_WARNING, "stringy results_key")
+  return nil
+elseif t == 'set' or t == 'zset' then
+  if runstate_key then
+    redis.call('set', runstate_key, 1)
+  end
+  return true
+end

data/data/redis_scripts/unpersist_reusable_temp_query_keys.lua

@@ -0,0 +1,11 @@
+local key = KEYS[1]
+
+local k, ttl
+for i, v in ipairs(redis.call('zrange', key, 0, -1, 'withscores')) do
+  if i%2==1 then k=v; else
+    ttl=v
+    redis.call('expire', k, ttl)
+    redis.log(redis.LOG_WARNING, "unpersisted key " .. k .. " ttl=" .. ttl)
+  end
+end
+redis.call('del', key)

data/data/redis_scripts/update_live_expiring_presence_index.lua

@@ -0,0 +1,20 @@
+local index_key, delta_key = KEYS[1], KEYS[2]
+local now, ttl, follow_schedule = tonumber(ARGV[1]), tonumber(ARGV[2]), ARGV[3]
+local too_old = now - ttl
+if follow_schedule=="true" then
+  local timer_key = delta_key .. ":timer"
+  if redis.call('exists', timer_key) == 1 then
+    return 0
+  else
+    redis.call('setex', timer_key, ttl/2, "don't update until this key expires") --ttl/2 is rather arbitrary
+  end
+end
+
+local res = redis.call('zrangebyscore', index_key, '-inf', too_old)
+if #res > 0 then
+  for i, id in ipairs(res) do
+    redis.call('zadd', delta_key, now, id)
+  end
+  redis.call('zremrangebyscore', index_key, '-inf', too_old)
+end
+return #res

data/data/redis_scripts/update_query.lua

@@ -0,0 +1,126 @@
+local log = function(msg, level)
+  local loglevel
+  if     level == 'debug' then loglevel=redis.LOG_DEBUG
+  elseif level == "notice" then loglevel=redis.LOG_NOTICE
+  elseif level == "verbose" then loglevel=redis.LOG_VERBOSE
+  elseif level == "warning" then loglevel=redis.LOG_WARNING
+  else loglevel=redis.LOG_WARNING end
+  local txt = ("query update: %s"):format(msg)
+  redis.log(loglevel, txt)
+  return txt
+end
+local query_marshaled_key= KEYS[1]
+local live_index_changesets_key = KEYS[2]
+local now = tonumber(ARGV[1])
+
+local delta_key, deltas = nil, {}
+local changeset = {}
+--assemble query changeset from live index changeset keys, noting the scores as we go along
+for i, v in ipairs(redis.call('zrange', live_index_changesets_key, 0, -1, 'withscores')) do
+  if i%2==1 then delta_key=v; else
+    local el, last = nil, v
+    local res = redis.call('zrevrangebyscore', delta_key, 'inf', '('..v, 'withscores')
+    for j, val in ipairs(res) do
+      --log("delta " .. j .. " " .. val)
+      if j%2==1 then el=val; else
+        if val > last then last = val end
+        changeset[el]=true
+      end
+    end
+    redis.call('zadd', live_index_changesets_key, last, delta_key)
+  end
+end
+
+if next(changeset) == nil then
+  return log("nothing changed, no updates to query", "debug")
+end
+
+local marshaled = redis.call("get", query_marshaled_key)
+if not marshaled then
+  return log("Queris couldn't update query with key " .. query_marshaled_key .. " : redis-friendly marshaled query contents not found.", "warning")
+end
+local success, query = pcall(cjson.decode, marshaled)
+if not success then
+  return log("Error unpacking json-serialized query at " .. query_marshaled_key .. " : " ..   query .. "\r\n " .. marshaled, "warning")
+end
+local query_member
+local is_member = function(op, id)
+  --log("" .. id .. " is_member?", "debug")
+  if op.query then
+    return query_member(op.query, id)
+  end
+  local t = redis.call('type', op.key).ok
+  if t == 'set' then
+    return redis.call('sismember', op.key, id) == 1
+  elseif t == 'zset' then
+    local score = tonumber(redis.call('zscore', op.key, id))
+    --log("found " .. id .. " in zset " .. op.key .. " with score " ..  score, "debug")
+    local m = score and true
+    if op.index == "ExpiringPresenceIndex" then
+      m = m and (score + op.ttl) >= now
+    else
+      if op.min then m = m and score > op.min end
+      if op.max then m = m and score < op.max end
+      if op.max_or_equal then m = m and score <= op.max_or_equal end
+      if op.equal then m = m and score == op.equal end
+    end
+    return m
+  elseif t == 'none' then
+    return false
+  else
+    log("Unexpected index type " .. (t or "?"), "warning")
+    return false
+  end
+end
+
+query_member = function(query, id)
+  --log("Query member? " .. id, "debug")
+  local revops = query.ops_reverse
+  for i, op in ipairs(revops) do
+    local member = is_member(op, id)
+    --log("OP: " .. op.op .. " member:" .. (member and "true" or "false") .. " id: " .. id .. " indexkey: " .. (op.key or "nokey"), 'debug')
+    if op.op == "intersect" then
+      if not member then
+        return false
+      elseif member and i == #revops then
+        return true
+      end
+    elseif op.op == "diff" then
+      if member then
+        return false
+      end
+    elseif op.op == "union" then
+      if member then
+        return true
+      end
+    end
+  end
+  return false
+end
+
+local score = function(ops, id)
+  --log("score " .. id, "debug")
+  local sum = 0
+  for i,op in ipairs(ops) do
+    local myscore = redis.call('zscore', op.key, id)
+    sum = sum+ op.multiplier * (myscore or 0)
+  end
+  return sum
+end
+
+local total, added, removed = 0, 0, 0
+
+for id,_ in pairs(changeset) do
+  total = total + 1
+  if query_member(query, id) then
+    local sc = score(query.sort_ops, id)
+    redis.call('zadd', query.key, sc, id)
+    added = added + 1
+  else
+    redis.call('zrem', query.key, id)
+    removed = removed + 1
+  end
+end
+local status_message = ("added %d, removed %d out of %d for %s"):format(added, removed, total, query.key)
+--log(status_message, "debug")
+return status_message

data/data/redis_scripts/update_rangehacks.lua

@@ -0,0 +1,94 @@
+local rangehacks_key, range_key = KEYS[1], KEYS[2]
+
+local function to_f(val)
+  if val=="-inf" then
+    return -math.huge
+  elseif val == 'inf' then
+    return math.huge
+  else
+    return tonumber(val)
+  end
+end
+
+local action, id, val = ARGV[1], ARGV[2], to_f(ARGV[3])
+
+local enable_debug=true
+local dbg = (function(on)
+  if on then return function(...) 
+    local arg, cur = {...}, nil
+    for i = 1, #arg do
+      arg[i]=tostring(arg[i])
+    end
+    redis.call('echo', table.concat(arg))
+  end; else
+    return function(...) return; end
+  end
+end)(enable_debug)
+
+dbg("##### UPDATE_RANGEHACKS ####")
+
+if action == "incr" then
+  dbg("translate incr to add")
+  local cur_val=redis.call('zscore', range_key, id)
+  if cur_val then
+    cur_val=to_f(cur_val)
+    val = cur_val + val
+  else
+    error("i don't know how to do this man")
+  end
+  action = "add"
+end
+
+local hacks = redis.call('smembers', rangehacks_key)
+
+local function update_hack(key)
+  dbg("update_hack ", key)
+  if action == "add" then 
+    redis.call('zadd', key, val, id)
+  elseif action == "del" then
+    redis.call('zrem', key, id)
+  else
+    --dbg(action, " none of the abose")
+    error(("%s action disallowed here. should've been converted to an add in this script"):format(action))
+  end
+end
+
+local function maybe_update_hack(key)
+  local hackval = key:match("^.*:(.*)$")
+  local hnum = to_f(hackval)
+  dbg("yeeah", key, "  ", hackval)
+  if hnum then
+    if hnum == val then
+      return update_hack(key)
+    else
+      --dbg("hackval ~= val ", hackval, "  ", val) 
+    end
+    return
+  end
+  
+  local min, interval, max = hackval:match("(.*%w)(%.%.%.?)(.*)")
+  --dbg("val: ", val, " FOUND ", min," ", interval, " ", max)
+  if min and interval and max then
+    min, max = to_f(min), to_f(max)
+    if interval == ".." then
+      if val >= min and val < max then
+        return update_hack(key)
+      end
+    else
+      if val >= min and val <= max then
+        return update_hack(key)
+      end
+    end
+    return
+  end
+
+end
+
+for i,hack_key in pairs(hacks) do
+  if redis.call('exists', hack_key) == 1 then
+    maybe_update_hack(hack_key, val)
+  else
+    --it's not there anymore
+    redis.call("srem", hack_key)
+  end
+end

data/data/redis_scripts/zrangestore.lua

@@ -0,0 +1,12 @@
+local res = redis.call("zrange", KEYS[2],  ARGV[1], ARGV[2], "withscores")
+local id, score
+if next(res) ~= nil then
+  redis.call('del', KEYS[1])
+end
+for i,v in ipairs(res) do
+  if i%2==1 then id=v; else
+    score=v
+    redis.call('zadd', KEYS[1], score, id)
+  end
+end
+return #res/2

data/lib/queris.rb

@@ -0,0 +1,400 @@
+# encoding: utf-8
+require "queris/version"
+require 'rubygems'
+require 'digest/sha1'
+require "queris/errors"
+require "queris/indices"
+require "queris/query"
+require "queris/mixin/object"
+require "queris/model"
+
+# Queris is a querying and indexing tool for various Ruby objects.
+module Queris
+  
+  @models = []
+  @model_lookup={}
+  @redis_connections=[]
+  @redis_by_role={}
+  @debug=false
+  @redis_scripts={}
+  class << self
+    attr_accessor :redis_scripts
+    attr_accessor :debug
+    def digest(val)
+      Digest::SHA1.hexdigest(val.to_s)
+    end
+    def debug?; @debug; end
+  
+    #retrieve redis connection matching given redis server role, in order or decreasing preference
+    def redis(*redis_roles)
+      redises(*redis_roles).sample || ($redis.kind_of?(Redis) ? $redis : nil) #for backwards compatibility with crappy old globals-using code.
+    end
+   
+    #returns another connection to the same server
+    def duplicate_redis_client(redis, role=false)
+      raise RedisException, "No redis client to duplicate."  unless redis
+      raise RedisException, "Not a redis client" unless Redis === redis
+      cl = redis.client
+      raise RedisException, "Redis client doesn't have connection info (Can't get client info while in a redis.multi block... for now...)" unless cl.host
+      r = Redis.new({
+                    port:      cl.port,
+                    host:      cl.host,
+                    path:      cl.path,
+                    timeout:   cl.timeout,
+                    password:  cl.password,
+                    db:        cl.db })
+      add_redis r, role
+    end
+    # get all redis connections for given redis server role.
+    # when more than one role is passed, treat them in order of decreasing preference
+    # when no role is given, :master is assumed
+
+    def redises(*redis_roles)
+      redis_roles << :master if redis_roles.empty? #default
+      redis_roles.each do |role|
+        unless (redises=@redis_by_role[role.to_sym]).nil? || redises.empty?
+          return redises
+        end
+      end
+      []
+    end
+
+    def load_lua_script(redis, name, contents)
+      begin
+        hash = redis.script 'load', contents
+      rescue Redis::CommandError => e
+        raise ClientError, "Error loading script #{name}: #{e}"
+      end
+      raise Error, "Failed loading script #{name} onto server: mismatched hash" unless script_hash(name) == hash
+    end
+    private :load_lua_script
+    
+    def add_redis(redis, *roles)
+      if !(Redis === redis) && (Redis === roles.first) # flipped aguments. that's okay, we accept those, too
+        redis, roles = roles.first, [ redis ]
+      end
+      roles << :master if roles.empty?
+      roles = [] if roles.length == 1 && !roles.first
+      @redis_connections << redis
+      roles.each do |role|
+        role = role.to_sym
+        @redis_by_role[role]||=[]
+        @redis_by_role[role] << redis
+      end
+      
+      #throw our lua scripts onto the server
+      redis_scripts.each do |name, contents|
+        load_lua_script redis, name, contents
+      end
+      
+      def track_stats?
+        @track_stats
+      end
+      def track_stats!
+        @track_stats = true
+      end
+      def stats
+        return false unless @track_stats
+        puts RedisStats.summary
+        return RedisStats
+      end
+      attr_accessor :log_stats_per_request
+      def log_stats_per_request?
+        @log_stats_per_request
+      end
+      def log_stats_per_request!
+        track_stats!
+        @log_stats_per_request = true
+      end
+      
+      #bolt on our custom logger
+      class << redis.client
+        protected
+        alias :_default_logging :logging
+        if Object.const_defined?('ActiveSupport') && ActiveSupport.const_defined?("Notifications")
+          #the following is one ugly monkey(patch).
+          # we assume that, since we're in Railsworld, the Redis logger
+          # is up for grabs. It would be cleaner to wrap the redis client in a class, 
+          # but I'm coding dirty for brevity. 
+          # THIS MUST BE ADDRESSED IN THE FUTURE
+          def logging(commands)
+            ActiveSupport::Notifications.instrument("command.queris") do
+              start = Time.now.to_f
+              ret = _default_logging(commands) { yield }
+              Queris::RedisStats.record(self, Time.now.to_f - start) if Queris.track_stats?
+              ret
+            end
+          end
+        else
+          def logging(commands)
+            start = Time.now.to_f
+            ret = _default_logging(commands) { yield }
+            Queris::RedisStats.record(self, Time.now.to_f - start) if Queris.track_stats?
+            ret
+          end
+        end
+      end
+      redis
+    end
+    
+    def clear_cache!
+      cleared = 0
+      @models.each { |model| cleared += model.clear_cache! }
+      cleared
+    end
+
+    def clear_queries!
+      cleared = 0
+      @models.each do |model|
+        cleared += model.clear_queries! || 0
+      end
+      cleared
+    end
+    
+    def clear!
+      clear_cache! + clear_queries!
+    end
+    
+    def info
+      models.each &:info
+    end
+    
+    #reconnect all redic clients
+    def reconnect
+      all_redises.each { |r| r.client.reconnect }
+    end
+    def disconnect
+      all_redises.each { |r| r.client.disconnect }
+    end
+    
+    def build_missing_indices!
+      @models.each do |model|
+        model.build_missing_redis_indices
+      end
+      self
+    end
+    
+    #rebuild all known queris indices
+    def rebuild!(clear=false)
+      start = Time.now
+      if Object.const_defined? 'Rails'
+        Dir.glob("#{Rails.root}/app/models/*.rb").sort.each { |file| require_dependency file } #load all models
+      end
+      @models.each do |model| 
+        if clear
+          delkeys = redis.keys "#{model.prefix}*"
+          redis.multi do |r|
+            delkeys.each { |k| redis.del k }
+          end
+          puts "Deleted #{delkeys.count} #{self.name} keys for #{model.name}."
+        end
+        model.build_redis_indices nil, false
+      end
+      printf "All redis indices rebuilt in %.2f sec.\r\n", Time.now-start
+      self
+    end
+
+    def all_redises; @redis_connections; end
+    def redis_role(redis)
+      @redis_by_role.each do |role, redises|
+        if Redis::Client === redis
+          return role if redises.map{|r| r.client}.member? redis
+        else
+          return role if redises.member? redis
+        end
+      end
+    end
+    attr_accessor :models
+    
+    def register_model(model)
+      unless @models.member? model
+        @models << model
+        @model_lookup[model.name.to_sym]=model
+      end
+    end
+
+    def model(model_name)
+      @model_lookup[model_name.to_sym]
+    end
+
+    def included(base)
+      base.send :include, ObjectMixin
+      if const_defined?('ActiveRecord') and base.superclass == ActiveRecord::Base then
+        require "queris/mixin/active_record"
+        base.send :include, ActiveRecordMixin
+      elsif const_defined?('Ohm') and base.superclass == Ohm::Model
+        require "queris/mixin/ohm"
+        base.send :include, OhmMixin
+      end
+    end
+  
+    def redis_prefix(app_name=nil)
+    #i'm using a simple string-concatenation key prefix scheme. I could have used something like Nest, but it seemed excessive.
+      if Object.const_defined? 'Rails'
+        "Rails:#{app_name || Rails.application.class.parent.to_s}:#{self.name}:"
+      elsif app_name.nil?
+        "#{self.name}:"
+      else
+        "#{app_name}:#{self.name}:"
+      end
+    end
+  
+    def to_redis_float(val)
+      val=val.to_f
+      case val
+      when Float::INFINITY
+        "inf"
+      when -Float::INFINITY
+        "-inf"
+      else
+        if val != val #NaN
+          "nan"
+        else
+          val
+        end
+      end
+    end
+    
+    def from_redis_float(val)
+      case val
+      when "inf", "+inf"
+        Float::INFINITY
+      when "-inf"
+        -Float::INFINITY
+      when "nan"
+        Float::NAN
+      else
+        val.to_f
+      end
+    end
+    
+    def script(name)
+      redis_scripts[name.to_sym]
+    end
+
+    def script_hash(name)
+      name = name.to_sym
+      @script_hash||={}
+      unless (hash=@script_hash[name])
+        contents = script(name)
+        raise  Error, "Unknown redis script #{name}." unless contents
+        hash = Queris.digest contents
+        @script_hash[name] = hash
+      end
+      hash
+    end
+    
+    def run_script(script, redis, keys=[], args=[])
+      begin
+        redis.evalsha script_hash(script), keys, args
+      rescue Redis::CommandError => e
+        raise Redis::CommandError, e.to_s.gsub(/^ERR Error running script/, "ERR Error running script #{script}")
+      end
+    end
+    
+    def import_lua_script(name, contents)
+      name=name.to_sym
+      if redis_scripts[name]
+        if redis_scripts[name]==contents
+          raise Queris::Error, "Tried loading script #{name} more than once. this is disallowed."
+        else
+          raise Queris::Error, "A redis lua script names #{name} already exists."
+        end
+      else
+        redis_scripts[name]=contents
+      end
+      all_redises.each do |r|
+        binding.pry
+        1+1.12
+        load_lua_script r, name, contents
+      end
+    end
+    #load redis lua scripts
+    Dir[File.join(File.dirname(__FILE__),'../data/redis_scripts/*.lua')].each do |path|
+      name = File.basename path, '.lua'
+      script = IO.read(path)
+      Queris.import_lua_script(name, script)
+    end
+  end
+  
+  class RedisStats
+    class << self
+      def record(redis, time)
+        @time ||= {}
+        @roundtrips ||= {}
+        @time[redis] = (@time[redis] || 0) + time
+        @roundtrips[redis] = (@roundtrips[redis] || 0) + 1
+        if @querying
+          @time_query ||= {}
+          @roundtrips_query ||= {}
+          @time_query[redis] = (@time_query[redis] || 0) + time
+          @roundtrips_query[redis] = (@roundtrips_query[redis] || 0) + 1
+        end
+        self
+      end
+      def querying=(val)
+        @querying=val
+      end
+      def time(redis)
+        (@time || {})[redis.client] || 0
+      end
+      def query_time(redis)
+        (@time_query || {})[redis.client] || 0
+      end
+      def roundtrips(redis)
+        (@roundtrips || {})[redis.client] || 0
+      end
+      def query_roundtrips(redis)
+        (@roundtrips_query || {})[redis.client] || 0
+      end
+      def reset
+        (@time || {}).clear
+        (@roundtrips || {}).clear
+        (@roundtrips_query || {}).clear
+        (@time_query || {}).clear
+        self
+      end
+      def summary
+        format = "%-10s %-7s %-10s %-5s %s"
+        ret = Queris.all_redises.map do |r|
+          format % [Queris.redis_role(r) || r.host, time(r).round(3), query_time(r).round(3), roundtrips(r), query_roundtrips(r)]
+        end
+        if ret.count>0
+          ret.unshift(format % ["", "all", "query", "all", "query"])
+          ret.unshift ("%-12s %-16s %s" % %w(Role Time(s) Roundtrips))
+        end
+        ret.empty? ? "no data" : ret.join("\r\n")
+      end
+      def totals(what=nil)
+        t, rt = 0, 0
+        Queris.all_redises.map do |r|
+          t += time(r)
+          rt += roundtrips(r)
+        end
+        if what == :time
+          "time: #{t.round(3)}sec"
+        elsif what == :roundtrips
+          "roundtrips: #{rt}"
+        else
+          "time: #{t.round(3)}sec, roundtrips: #{rt}"
+        end
+      end
+    end
+  end
+end
+
+#ugly rails hooks
+if Object.const_defined? 'Rails'
+  require "rails/log_subscriber"
+  require "rails/request_timing"
+end
+#ugly rake hooks
+if Object.const_defined? 'Rake'
+  if Object.const_defined? 'Rails'
+    class QuerisTasks < Rails::Railtie
+      rake_tasks do
+        Dir[File.join(File.dirname(__FILE__),'tasks/*.rake')].each { |f| load f }
+      end
+    end
+  end
+end