influxer 0.0.1 → 0.1.0

data/lib/influxer/metrics/relation.rb

@@ -1,12 +1,72 @@
+require 'influxer/metrics/relation/time_query'
+require 'influxer/metrics/relation/fanout_query'
+
 module Influxer
   class Relation
+    attr_reader :values
+
+    include Influxer::TimeQuery
+    include Influxer::FanoutQuery
     
+    MULTI_VALUE_METHODS = [:select, :where, :group]
+
+    MULTI_KEY_METHODS = [:fanout]
+
+    SINGLE_VALUE_METHODS = [:fill, :limit, :merge, :time]
+
+    MULTI_VALUE_SIMPLE_METHODS = [:select, :group]
+
+    SINGLE_VALUE_SIMPLE_METHODS = [:fill, :limit, :merge]
+
+    MULTI_VALUE_METHODS.each do |name|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}_values                          # def select_values
+          @values[:#{name}] ||= []                  #   @values[:select] || []
+        end                                         # end
+      CODE
+    end
+
+    MULTI_KEY_METHODS.each do |name|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}_values                          # def fanout_values
+          @values[:#{name}] ||= {}                  #   @values[:fanout] || {}
+        end                                         # end
+      CODE
+    end
+
+    SINGLE_VALUE_METHODS.each do |name|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}_value                           # def limit_value
+          @values[:#{name}]                         #   @values[:limit]
+        end                                         # end
+      CODE
+    end
+
+    SINGLE_VALUE_SIMPLE_METHODS.each do |name|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}(val)                            # def limit(val)
+          @values[:#{name}] = val                   #   @value[:limit] = val
+          self                                      #   self
+        end                                         # end
+      CODE
+    end
+
+    MULTI_VALUE_SIMPLE_METHODS.each do |name|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}(*args)                          # def select(*args)
+          #{name}_values.concat args.map(&:to_s)    #  select_values.concat args.map(&:to_s)
+          self                                      #  self
+        end                                         # end
+      CODE
+    end
+
     # Initialize new Relation for 'klass' (Class) metrics.
     # 
     # Available params:
     #  :attributes - hash of attributes to be included to new Metrics object and where clause of Relation
     # 
     def initialize(klass, params = {})
+      @klass = klass
       @instance = klass.new params[:attributes]
       self.reset
       self.where(params[:attributes]) if params[:attributes].present?
@@ -26,59 +86,46 @@ module Influxer
       @instance
     end
 
-    # accepts strings and symbols only
-    def select(*args)
-      return self if args.empty?
-      @select_values.concat args
-      self
-    end
-
     # accepts hash or strings conditions
-    # TODO: add sanitization and array support
-
     def where(*args,**hargs)
-      @where_values.concat args.map{|str| "(#{str})"}
-      
-      unless hargs.empty?
-        hargs.each do |key, val|
-          @where_values << "(#{key}=#{quoted(val)})"
-        end
-      end
-      self
-    end
-
-    def group(*args)
-      return self if args.empty?
-      @group_values.concat args
+      build_where(args, hargs, false)
       self
     end
 
-    def limit(val)
-      @limit = val
+    def not(*args, **hargs)
+      build_where(args, hargs, true)
       self
     end
 
     def to_sql
       sql = ["select"]
 
-      if @select_values.empty?
+      if select_values.empty?
         sql << "*"
       else
-        sql << @select_values.join(",")
+        sql << select_values.uniq.join(",")
       end 
 
-      sql << "from #{@instance.series}"
+      sql << "from #{ build_series_name }"
+
+      unless merge_value.nil?
+        sql << "merge #{ @instance.quote_series(merge_value) }"
+      end
+
+      unless group_values.empty? and time_value.nil?
+        sql << "group by #{ (time_value.nil? ? [] : ['time('+@values[:time]+')']).concat(group_values).uniq.join(",") }"
+      end
 
-      unless @group_values.empty?
-        sql << "group by #{@group_values.join(",")}"
+      unless fill_value.nil?
+        sql << "fill(#{ fill_value })"
       end
 
-      unless @where_values.empty?
-        sql << "where #{@where_values.join(" and ")}"
+      unless where_values.empty?
+        sql << "where #{ where_values.join(" and ") }"
       end
 
-      unless @limit.nil?
-        sql << "limit #{@limit}"
+      unless limit_value.nil?
+        sql << "limit #{ limit_value }"
       end
       sql.join " "
     end
@@ -101,12 +148,96 @@ module Influxer
     end
 
     def delete_all
+      sql = ["delete"]
+
+      sql << "from #{@instance.series}"
+
+      unless where_values.empty?
+        sql << "where #{where_values.join(" and ")}"
+      end
+
+      sql = sql.join " "
+
+      @instance.client.query sql
+    end
+
+    def scoping
+      previous, @klass.current_scope = @klass.current_scope, self
+      yield
+    ensure
+      @klass.current_scope = previous
+    end
+
+    def merge!(rel)
+      return self if rel.nil?
+      MULTI_VALUE_METHODS.each do |method|
+        (@values[method]||=[]).concat(rel.values[method]).uniq! unless rel.values[method].nil?
+      end
+
+      MULTI_KEY_METHODS.each do |method|
+        (@values[method]||={}).merge!(rel.values[method]) unless rel.values[method].nil?
+      end
+
+      SINGLE_VALUE_METHODS.each do |method|
+        @values[method] = rel.values[method] unless rel.values[method].nil?
+      end
 
+      self
     end
 
     protected
+      def build_where(args, hargs, negate)
+        case
+        when (args.present? and args[0].is_a?(String))
+          where_values.concat args.map{|str| "(#{str})"}
+        when hargs.present?
+          build_hash_where(hargs, negate)
+        else
+          false
+        end
+      end
+
+      def build_hash_where(hargs, negate = false)
+        hargs.each do |key, val|
+          if @klass.fanout?(key)
+            build_fanout(key,val)
+          else
+            where_values << "(#{ build_eql(key,val,negate) })"
+          end
+        end
+      end
+
+      def build_eql(key,val,negate)
+        case val
+        when Regexp
+          "#{key}#{ negate ? '!~' : '=~'}#{val.inspect}"
+        when Array
+          build_in(key,val,negate)
+        when Range
+          build_range(key,val,negate)
+        else
+          "#{key}#{ negate ? '<>' : '='}#{quoted(val)}"
+        end  
+      end
+
+      def build_in(key, arr, negate)
+        buf = []
+        arr.each do |val|
+          buf << build_eql(key,val,negate)
+        end
+        "#{ buf.join( negate ? ' and ' : ' or ') }"
+      end
+
+      def build_range(key,val,negate)
+        unless negate
+          "#{key}>#{quoted(val.begin)} and #{key}<#{quoted(val.end)}"
+        else
+          "#{key}<#{quoted(val.begin)} and #{key}>#{quoted(val.end)}"
+        end  
+      end
+
       def load
-        @records = @instance.client.query to_sql
+        @records = get_points(@instance.client.cached_query(to_sql))
         @loaded = true
       end
 
@@ -115,10 +246,7 @@ module Influxer
       end
 
       def reset
-        @limit = nil
-        @select_values = []
-        @group_values = []
-        @where_values = []
+        @values = {}
         @records = nil
         @loaded = false
         self
@@ -131,7 +259,7 @@ module Influxer
       end
 
       def quoted(val)
-        if val.is_a?(String)
+        if val.is_a?(String) or val.is_a?(Symbol)
           "'#{val}'"
         elsif val.kind_of?(Time) or val.kind_of?(DateTime)
           "#{val.to_i}s"
@@ -139,5 +267,15 @@ module Influxer
           val.to_s
         end
       end
+
+      def method_missing(method, *args, &block)
+        if @klass.respond_to?(method)    
+          merge!(scoping { @klass.public_send(method, *args, &block) })
+        end
+      end
+
+      def get_points(hash)
+        hash.values.reduce([],:+)
+      end
   end
 end 

data/lib/influxer/metrics/scoping/default.rb

@@ -0,0 +1,28 @@
+module Influxer
+  module Scoping
+    module Default
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :default_scopes
+        self.default_scopes = []
+      end
+
+      module ClassMethods
+        def default_scope(scope)
+          self.default_scopes += [scope] unless scope.nil?
+        end
+
+        def unscoped
+          Relation.new self
+        end
+
+        def default_scoped
+          self.default_scopes.inject(Relation.new(self)) do |rel, scope| 
+            rel.merge!(rel.scoping{ scope.call })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/influxer/metrics/scoping/named.rb

@@ -0,0 +1,18 @@
+module Influxer
+  module Scoping
+    module Named
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def scope(name, scope)
+          raise Error.new("Scope not defined: #{name}") if scope.nil? or !scope.respond_to?(:call)
+          singleton_class.send(:define_method, name) do |*args|
+            rel = all
+            rel.merge!(rel.scoping { scope.call(*args) })
+            rel
+          end
+        end
+      end
+    end
+  end
+end

data/lib/influxer/metrics/scoping.rb

@@ -0,0 +1,56 @@
+require 'active_support/per_thread_registry'
+require 'influxer/metrics/scoping/default'
+require 'influxer/metrics/scoping/named'
+
+module Influxer
+  module Scoping
+    extend ActiveSupport::Concern
+
+    class Error < StandardError; end;
+
+    included do
+      include Default
+      include Named
+    end
+
+    module ClassMethods
+      def current_scope #:nodoc:
+        ScopeRegistry.value_for(:current_scope, name)
+      end
+
+      def current_scope=(scope) #:nodoc:
+        ScopeRegistry.set_value_for(:current_scope, name, scope)
+      end
+    end
+
+    class ScopeRegistry # :nodoc:
+      extend ActiveSupport::PerThreadRegistry
+
+      VALID_SCOPE_TYPES = [:current_scope]
+
+      def initialize
+        @registry = Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      # Obtains the value for a given +scope_name+ and +variable_name+.
+      def value_for(scope_type, variable_name)
+        raise_invalid_scope_type!(scope_type)
+        @registry[scope_type][variable_name]
+      end
+
+      # Sets the +value+ for a given +scope_type+ and +variable_name+.
+      def set_value_for(scope_type, variable_name, value)
+        raise_invalid_scope_type!(scope_type)
+        @registry[scope_type][variable_name] = value
+      end
+
+      private
+
+      def raise_invalid_scope_type!(scope_type)
+        if !VALID_SCOPE_TYPES.include?(scope_type)
+          raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
+        end
+      end
+    end
+  end
+end

data/lib/influxer/model.rb

@@ -17,8 +17,10 @@ module Influxer
           attrs = params[:inherits]
         end
 
+        _foreign_key = params.key?(:foreign_key) ? params[:foreign_key] : self.to_s.foreign_key
+
         define_method(metrics_name) do
-          rel_attrs = {self.class.to_s.foreign_key => self.id}
+          rel_attrs = _foreign_key ? {_foreign_key => self.id} : {}
           
           unless attrs.nil?
             attrs.each do |key|

data/lib/influxer/version.rb

@@ -1,3 +1,3 @@
 module Influxer
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/client_spec.rb

@@ -2,6 +2,10 @@ require 'spec_helper'
 
 describe Influxer::Client do
 
+  after(:each) do
+    Rails.cache.clear
+  end
+
   let(:conf) { Influxer.config }
   let(:client) { Influxer.client }
 
@@ -11,4 +15,34 @@ describe Influxer::Client do
     expect(client.database).to eq conf.database
   end
 
+  describe "cache" do
+    before do
+      allow_any_instance_of(Influxer::Client).to receive(:query) do |_, sql|   
+        sql
+      end
+    end
+
+    let(:q) { "list series" }
+
+    after(:each) do
+      conf.cache = false
+    end
+
+    it "should write data to cache" do
+      conf.cache = {}
+
+      client.cached_query(q)
+      expect(Rails.cache.exist?("influxer:listseries")).to be_truthy
+    end
+
+    it "should write data to cache with expiration" do
+      conf.cache = {expires_in: 1}
+
+      client.cached_query(q)
+      expect(Rails.cache.exist?("influxer:listseries")).to be_truthy
+      
+      sleep 2
+      expect(Rails.cache.exist?("influxer:listseries")).to be_falsey
+    end
+  end
 end

data/spec/dummy/app/metrics/testo_metrics.rb

@@ -1,3 +1,3 @@
 class TestoMetrics < Influxer::Metrics
-  attributes :testo_id, :receipt_id
+  attributes :testo_id, :receipt_id, :testo
 end

data/spec/dummy/app/models/testo.rb

@@ -1,4 +1,6 @@
 class Testo < ActiveRecord::Base
   has_metrics
   has_metrics :testo_metrics, class_name: "TestoMetrics", inherits: [:receipt_id]
+  has_metrics :testo2_metrics, class_name: "TestoMetrics", foreign_key: :testo
+  has_metrics :custom_metrics, class_name: "TestoMetrics", foreign_key: nil
 end

data/spec/dummy/config/application.rb

@@ -7,6 +7,7 @@ require "influxer"
 
 module Dummy
   class Application < Rails::Application
+    config.cache_store = :memory_store
     # Settings in config/environments/* take precedence over those specified here.
     # Application configuration should go into files in config/initializers
     # -- all .rb files in that directory are automatically loaded.

data/spec/dummy/config/environments/test.rb

@@ -1,6 +1,5 @@
 Dummy::Application.configure do
   # Settings specified here will take precedence over those in config/application.rb.
-
   # The test environment is used exclusively to run your application's
   # test suite. You never need to work with it otherwise. Remember that
   # your test database is "scratch space" for the test suite and is wiped

data/spec/metrics/fanout_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Influxer::Metrics do
+  before do
+    allow_any_instance_of(Influxer::Client).to receive(:query) do |_, sql|    
+      sql
+    end
+  end
+
+  let(:dummy) do
+    Class.new(Influxer::Metrics) do
+      set_series 'dummy'
+      default_scope -> { time(:hour) }
+    end
+  end
+
+  let(:doomy) do
+    Class.new(dummy) do
+      scope :by_user, -> (id) { where(user: id) if id.present? }
+      scope :hourly, -> { where(by: :hour).time(nil) }
+      scope :daily, -> { where(by: :day).time(nil) }
+
+      fanout :by, :user, :account, delimeter: "."
+    end
+  end
+
+  let(:dappy) do
+    Class.new(doomy) do
+      fanout :user, delimeter: "_"
+    end
+  end
+
+  describe "fanouts" do
+    it "should work with one fanout" do
+      expect(doomy.by_user(1).to_sql).to eq "select * from \"dummy.user.1\" group by time(1h)"
+    end
+
+    it "should work with several fanouts" do
+      expect(dappy.by_user(1).hourly.to_sql).to eq "select * from \"dummy_by_hour_user_1\""
+    end
+
+    it "should work with regexp fanouts" do
+      expect(dappy.where(dummy_id: 100).by_user(/[1-3]/).daily.to_sql).to eq "select * from merge(/^dummy_by_day_user_[1-3]$/) where (dummy_id=100)"
+    end
+  end
+end

data/spec/metrics/metrics_spec.rb

@@ -1,6 +1,11 @@
 require 'spec_helper'
 
 describe Influxer::Metrics do
+  before do
+    allow_any_instance_of(Influxer::Client).to receive(:query) do |_, sql|    
+      sql
+    end
+  end
 
   let(:metrics) { Influxer::Metrics.new }
   let(:metrics_class) { Influxer::Metrics }
@@ -16,7 +21,10 @@ describe Influxer::Metrics do
   
   specify { expect(metrics_class).to respond_to :all}
   specify { expect(metrics_class).to respond_to :where}
-  specify { expect(metrics_class).to respond_to :group}
+  specify { expect(metrics_class).to respond_to :merge}
+  specify { expect(metrics_class).to respond_to :time}
+  specify { expect(metrics_class).to respond_to :past}
+  specify { expect(metrics_class).to respond_to :since}
   specify { expect(metrics_class).to respond_to :limit}
   specify { expect(metrics_class).to respond_to :select}
   specify { expect(metrics_class).to respond_to :delete_all}
@@ -86,12 +94,30 @@ describe Influxer::Metrics do
       end
     end
 
+    let(:dummy_metrics_2) do
+      Class.new(Influxer::Metrics) do
+        set_series "dummy \"A\""       
+      end
+    end
+
+    let(:dummy_metrics_3) do
+      Class.new(Influxer::Metrics) do
+        set_series /^.*$/       
+      end
+    end
+
     let(:dummy_with_2_series) do
       Class.new(Influxer::Metrics) do
         set_series :events, :errors       
       end
     end
 
+    let(:dummy_with_2_series_quoted) do
+      Class.new(Influxer::Metrics) do
+        set_series "dummy \"A\"", "dummy \"B\""        
+      end
+    end
+
     let(:dummy_with_proc_series) do
       Class.new(Influxer::Metrics) do
         attributes :user_id, :test_id
@@ -99,27 +125,36 @@ describe Influxer::Metrics do
       end
     end
 
-
-
     describe "set_series" do
       it "should set series name from class name by default" do
-        expect(DummyMetrics.series).to eq 'dummy'
+        expect(DummyMetrics.new.series).to eq "\"dummy\""
       end
 
       it "should set series from subclass" do
-        expect(dummy_metrics.series).to eq 'dummies'
+        expect(dummy_metrics.new.series).to eq "\"dummies\""
+      end
+
+      it "should set series as regexp" do
+        expect(dummy_metrics_3.new.series).to eq '/^.*$/'
+      end
+
+      it "should set series with quotes" do
+        expect(dummy_metrics_2.new.series).to eq "\"dummy \\\"A\\\"\""
       end
 
       it "should set several series" do
-        expect(dummy_with_2_series.series).to eq 'events,errors'
+        expect(dummy_with_2_series.new.series).to eq "merge(\"events\",\"errors\")"
       end
 
+      it "should set several series with quotes" do
+        expect(dummy_with_2_series_quoted.new.series).to eq "merge(\"dummy \\\"A\\\"\",\"dummy \\\"B\\\"\")"
+      end
 
       it "should set series from proc" do
         expect(dummy_with_proc_series.series).to be_an_instance_of Proc
 
         m = dummy_with_proc_series.new user_id: 2, test_id:123
-        expect(dummy_with_proc_series.series.call(m)).to eq "test/123/user/2"
+        expect(m.series).to eq "\"test/123/user/2\""
       end
     end