tally 1.0.0.beta1

data/lib/tally/daily.rb

@@ -0,0 +1,64 @@
+module Tally
+  # Contains all keys set for the given day
+  #
+  # Can be used to iterate over a large amount of smembers in the daily set
+  class Daily < KeyFinder
+
+    def daily_key
+      "#{ Tally.config.prefix }@#{ day_key }"
+    end
+
+    private
+
+      def all_keys
+        @keys ||= build_keys_from_redis
+      end
+
+      def build_keys_from_redis
+        result = []
+        cursor = ""
+
+        scan = scan_from_redis
+
+        while cursor != "0"
+          result << scan.last
+          cursor = scan.first
+
+          scan = scan_from_redis(cursor: cursor)
+        end
+
+        result.flatten
+      end
+
+      def day_key
+        @day_key ||= day.strftime(Tally.config.date_format)
+      end
+
+      def entry_regex
+        @entry_regex ||= Regexp.new("(?<record>[^:]+:[\\d]+)?:?(?<key>[^:]+)")
+      end
+
+      def scan_from_redis(cursor: "0")
+        Tally.redis do |conn|
+          conn.sscan(daily_key, cursor, match: scan_key, count: 25)
+        end
+      end
+
+      def scan_key
+        @scan_key ||= if key.present? && record.present?
+          "#{ record.model_name.i18n_key }:#{ record.id }:#{ key }"
+        elsif key.present? && type.present?
+          "#{ type }:*:#{ key }"
+        elsif record.present?
+          "#{ record.model_name.i18n_key }:#{ record.id }:*"
+        elsif type.present?
+          "#{ type }:*:*"
+        elsif key.present?
+          "*#{ key }"
+        else
+          "*"
+        end
+      end
+
+  end
+end

data/lib/tally/engine.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Tally
+  class Engine < ::Rails::Engine
+
+    isolate_namespace Tally
+
+    engine_name "tally"
+
+    # Run migrations in the main app without copying
+    # From: https://content.pivotal.io/blog/leave-your-migrations-in-your-rails-engines
+    initializer "tally.append_migrations" do |app|
+      unless app.root.to_s.match root.to_s
+        config.paths["db/migrate"].expanded.each do |expanded_path|
+          app.config.paths["db/migrate"] << expanded_path
+        end
+      end
+    end
+
+    # Allow approved helpers to be included in the main app
+    initializer "tally.expose_helpers" do |app|
+      ActiveSupport.on_load :action_controller do
+        ActionController::Base.helper Tally::IncrementHelper
+      end
+    end
+
+  end
+end

data/lib/tally/increment.rb

@@ -0,0 +1,25 @@
+module Tally
+  class Increment
+
+    include Keyable
+
+    def increment(by = 1)
+      Tally.redis do |conn|
+        conn.multi do
+          conn.incrby(redis_key, by)
+          conn.expire(redis_key, Tally.config.ttl) if Tally.config.ttl.present?
+
+          conn.sadd(daily_key, simple_key)
+          conn.expire(daily_key, Tally.config.ttl) if Tally.config.ttl.present?
+        end
+      end
+    end
+
+    def self.increment(key, record = nil, by = 1)
+      instance = new(key, record)
+      instance.increment(by)
+      instance = nil
+    end
+
+  end
+end

data/lib/tally/key_finder.rb

@@ -0,0 +1,123 @@
+module Tally
+  # Locates keys for a given day, key, and/or record
+  class KeyFinder
+
+    extend ActiveSupport::Autoload
+
+    autoload :Entry
+
+    attr_reader :key
+    attr_reader :record
+    attr_reader :type
+
+    def initialize(key: nil, day: nil, record: nil, type: nil)
+      @key = key.to_s.gsub(":", ".").downcase.strip if key.present?
+      @day = day
+      @record = record
+      @type = type unless record.present?
+
+      @day = @day.to_date if Time === @day
+    end
+
+    def day
+      @day ||= Time.current.utc.to_date
+    end
+
+    def entries
+      @entries ||= all_keys.map do |key|
+        if match = key.match(entry_regex)
+          Entry.new(match, key, day)
+        end
+      end.compact
+    end
+
+    def keys
+      entries.map(&:key).compact.uniq
+    end
+
+    def raw_keys
+      all_keys
+    end
+
+    # load up all records for the given keys, tries to batch them by model type
+    # so there's not an N+1 here
+    def records
+      models = entries.reduce({}) do |result, entry|
+        result[entry.type] ||= []
+        result[entry.type].push(entry.id)
+        result
+      end
+
+      models.map do |model, ids|
+        next unless ids.compact.any?
+
+        if klass = model.to_s.classify.safe_constantize
+          klass.where(id: ids)
+        end
+      end.compact.flatten
+    end
+
+    def types
+      entries.map(&:type).compact.uniq
+    end
+
+    def self.find(*args)
+      new(*args).entries
+    end
+
+    private
+
+      def all_keys
+        @keys ||= build_keys_from_redis
+      end
+
+      def build_keys_from_redis
+        result = []
+        cursor = ""
+
+        scan = scan_from_redis
+
+        while cursor != "0"
+          result << scan.last
+          cursor = scan.first
+
+          scan = scan_from_redis(cursor: cursor)
+        end
+
+        result.flatten
+      end
+
+      def day_key
+        @day_key ||= if day == "*"
+          "*"
+        else
+          day.strftime(Tally.config.date_format)
+        end
+      end
+
+      def entry_regex
+        @entry_regex ||= Regexp.new("#{ Tally.config.prefix }:?(?<record>[^:]+:[\\d]+)?:?(?<key>[^:]+)?@")
+      end
+
+      def scan_from_redis(cursor: "0")
+        Tally.redis { |conn| conn.scan(cursor, match: scan_key) }
+      end
+
+      def scan_key
+        @scan_key ||= if key.present? && record.present?
+          "#{ Tally.config.prefix }:#{ record.model_name.i18n_key }:#{ record.id }:#{ key }@#{ day_key }"
+        elsif key.present? && type.present?
+          "#{ Tally.config.prefix }:#{ type }:*:#{ key }@#{ day_key }"
+        elsif record.present?
+          "#{ Tally.config.prefix }:#{ record.model_name.i18n_key }:#{ record.id }:*@#{ day_key }"
+        elsif type.present?
+          "#{ Tally.config.prefix }:#{ type }:*:*@#{ day_key }"
+        elsif key.present?
+          "#{ Tally.config.prefix }:*#{ key }@#{ day_key }"
+        else
+          "#{ Tally.config.prefix }*@#{ day_key }"
+        end
+      end
+
+  end
+end

data/lib/tally/key_finder/entry.rb

@@ -0,0 +1,66 @@
+module Tally
+  class KeyFinder::Entry
+
+    attr_reader :raw_key
+
+    def initialize(match, raw_key, date)
+      @match    = match
+      @raw_key  = raw_key
+      @date     = date if Date === date
+    end
+
+    def date
+      @date ||= build_date_from_raw_key
+    end
+
+    def id
+      @id ||= if match[:record]
+        match[:record].split(":").last.to_i
+      end
+    end
+
+    def key
+      match[:key]
+    end
+
+    def record
+      return nil unless type.present?
+      return nil unless id.present? && id > 0
+
+      if model = type.classify.safe_constantize
+        model.find_by(id: id)
+      end
+    end
+
+    def type
+      @type ||= if match[:record]
+        match[:record].split(":").first
+      end
+    end
+
+    def value
+      Tally.redis do |conn|
+        conn.get(key_for_value_lookup).to_i
+      end
+    end
+
+    private
+
+      attr_reader :match
+
+      def build_date_from_raw_key
+        if raw_key.to_s =~ /@/
+          Date.parse(raw_key.to_s.split("@").last)
+        end
+      end
+
+      def key_for_value_lookup
+        if raw_key.starts_with?("#{ Tally.config.prefix }:")
+          raw_key
+        else
+          "#{ Tally.config.prefix }:#{ raw_key }@#{ date&.strftime('%Y-%m-%d') }"
+        end
+      end
+
+  end
+end

data/lib/tally/keyable.rb

@@ -0,0 +1,55 @@
+require "active_support/concern"
+
+module Tally
+  module Keyable
+
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :key
+      attr_reader :record
+    end
+
+    def initialize(key, record = nil)
+      @key = key.to_s.gsub(":", ".").downcase.strip
+      @record = record
+    end
+
+    def day
+      @day ||= Time.current.utc.to_date
+    end
+
+    private
+
+      def daily_key
+        "#{ prefix }@#{ date_key }"
+      end
+
+      def date_key
+        @date_key ||= day.strftime(Tally.config.date_format)
+      end
+
+      def prefix
+        Tally.config.prefix
+      end
+
+      def record_key
+        if record
+          "#{ record.model_name.i18n_key }:#{ record.id }"
+        end
+      end
+
+      def redis_key
+        @redis_key ||= "#{ prefix }:#{ simple_key }@#{ date_key }"
+      end
+
+      def simple_key
+        @simple_key ||= if record.respond_to?(:model_name)
+          "#{ record_key }:#{ key }"
+        else
+          key
+        end
+      end
+
+  end
+end

data/lib/tally/record_searcher.rb

@@ -0,0 +1,110 @@
+module Tally
+  class RecordSearcher
+
+    attr_reader :params
+
+    def initialize(params = {})
+      @params = params || {}
+
+      if ActionController::Parameters === params
+        if params.permitted?
+          @params = params.to_h
+        else
+          @params = {}
+        end
+      end
+
+      @params = @params.symbolize_keys
+    end
+
+    def days
+      @keys ||= build_search_scope.select(:day).distinct.reorder(day: :desc)
+    end
+
+    def keys
+      @keys ||= build_search_scope.select(:key).distinct.reorder(:key)
+    end
+
+    def records
+      @records ||= build_search_scope
+    end
+
+    def self.search(*args)
+      new(*args).records
+    end
+
+    private
+
+      def build_recordable_from_params
+        id = params[:id].to_i
+        model = params[:type].to_s.classify.safe_constantize
+
+        if id > 0 && model.respond_to?(:find_by_id)
+          model.find_by_id(id)
+        end
+      end
+
+      def build_search_scope
+        scope = Record.all
+
+        if recordable
+          scope = scope.where(recordable: recordable)
+        elsif params[:type].present?
+          scope = scope.where(recordable_type: params[:type])
+        end
+
+        if key
+          scope = scope.where(key: key)
+        end
+
+        if start_date && end_date
+          scope = scope.where(day: (start_date..end_date))
+        elsif start_date
+          scope = scope.where(day: start_date..Float::INFINITY)
+        elsif end_date
+          scope = scope.where(Record.arel_table[:day].lteq(end_date))
+        end
+
+        scope.order(day: :desc)
+      end
+
+      def end_date
+        if params[:end_date]
+          @end_date ||= to_date(:end_date)
+        end
+      end
+
+      def key
+        if params[:key].present?
+          @key ||= params[:key].to_s.gsub(":", ".").downcase.strip
+        end
+      end
+
+      def recordable
+        @recordable ||= if ActiveRecord::Base === params[:record]
+          params[:record]
+        elsif params[:id] && params[:type]
+          build_recordable_from_params
+        end
+      end
+
+      def start_date
+        if params[:start_date]
+          @start_date ||= to_date(:start_date)
+        end
+      end
+
+      def to_date(param_key)
+        value = params[param_key].presence
+        return nil unless value.present?
+        return value if value.is_a?(Date)
+        return value.to_date if value.is_a?(DateTime)
+        return value.to_date if value.is_a?(Time)
+
+        Date.parse(value)
+      rescue
+        nil
+      end
+
+  end
+end