influxer 0.2.4 → 0.3.1

data/lib/influxer/metrics/relation.rb

@@ -1,25 +1,26 @@
 require 'influxer/metrics/relation/time_query'
-require 'influxer/metrics/relation/fanout_query'
 require 'influxer/metrics/relation/calculations'
+require 'influxer/metrics/relation/where_clause'
 
 module Influxer
   # Relation is used to build queries
+  # rubocop:disable Metrics/ClassLength
   class Relation
     include Influxer::TimeQuery
-    include Influxer::FanoutQuery
     include Influxer::Calculations
+    include Influxer::WhereClause
 
     attr_reader :values
 
-    MULTI_VALUE_METHODS = [:select, :where, :group]
+    MULTI_VALUE_METHODS = [:select, :where, :group, :order]
 
     MULTI_KEY_METHODS = [:fanout]
 
-    SINGLE_VALUE_METHODS = [:fill, :limit, :merge, :time]
+    SINGLE_VALUE_METHODS = [:fill, :time, :limit, :offset, :slimit, :soffset, :normalized]
 
     MULTI_VALUE_SIMPLE_METHODS = [:select, :group]
 
-    SINGLE_VALUE_SIMPLE_METHODS = [:fill, :limit, :merge]
+    SINGLE_VALUE_SIMPLE_METHODS = [:fill, :limit, :offset, :slimit, :soffset]
 
     MULTI_VALUE_METHODS.each do |name|
       class_eval <<-CODE, __FILE__, __LINE__ + 1
@@ -82,50 +83,76 @@ module Influxer
     end
 
     def write(params = {})
-      build params
-      @instance.write
+      build(params).write
+    end
+
+    def write!(params = {})
+      build(params).write!
     end
 
     def build(params = {})
+      point = @instance.dup
       params.each do |key, val|
-        @instance.send("#{key}=", val) if @instance.respond_to?(key)
+        point.send("#{key}=", val) if point.respond_to?(key)
       end
-      @instance
+      point
     end
 
-    # accepts hash or strings conditions
-    def where(*args, **hargs)
-      build_where(args, hargs, false)
+    alias_method :new, :build
+
+    def normalized
+      @values[:normalized] = true
       self
     end
 
-    def not(*args, **hargs)
-      build_where(args, hargs, true)
+    def normalized?
+      @values[:normalized] == true
+    end
+
+    def order(val)
+      case val
+      when Hash
+        val.each { |k, v| order_values << "#{k} #{v}" }
+      when String
+        order_values << val
+      end
       self
     end
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/PerceivedComplexity
     def to_sql
       sql = ["select"]
       select_values << "*" if select_values.empty?
 
       sql << select_values.uniq.join(",")
 
-      sql << "from #{ build_series_name }"
-      sql << "merge #{ @klass.quoted_series(merge_value) }" unless merge_value.nil?
+      sql << "from #{build_series_name}"
+
+      sql << "where #{where_values.join(' and ')}" unless where_values.empty?
 
       unless group_values.empty? && time_value.nil?
         group_fields = (time_value.nil? ? [] : ['time(' + @values[:time] + ')']) + group_values
         group_fields.uniq!
-        sql << "group by #{ group_fields.join(',') }"
+        sql << "group by #{group_fields.join(',')}"
       end
 
-      sql << "fill(#{ fill_value })" unless fill_value.nil?
+      sql << "fill(#{fill_value})" unless fill_value.nil?
 
-      sql << "where #{ where_values.join(' and ') }" unless where_values.empty?
+      sql << "order by #{order_values.uniq.join(',')}" unless order_values.empty?
 
-      sql << "limit #{ limit_value }" unless limit_value.nil?
+      sql << "limit #{limit_value}" unless limit_value.nil?
+      sql << "offset #{offset_value}" unless offset_value.nil?
+      sql << "slimit #{slimit_value}" unless slimit_value.nil?
+      sql << "soffset #{soffset_value}" unless soffset_value.nil?
       sql.join " "
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/PerceivedComplexity
 
     def to_a
       return @records if loaded?
@@ -153,13 +180,13 @@ module Influxer
     end
 
     def load
-      @records = get_points(@instance.client.cached_query(to_sql))
+      @records = get_points(@instance.client.query(to_sql, denormalize: !normalized?))
       @loaded = true
       @records
     end
 
     def delete_all
-      sql = ["delete"]
+      sql = ["drop series"]
 
       sql << "from #{@instance.series}"
 
@@ -167,7 +194,7 @@ module Influxer
 
       sql = sql.join " "
 
-      @instance.client.query sql
+      @instance.client.exec sql
     end
 
     def scoping
@@ -177,6 +204,8 @@ module Influxer
       @klass.current_scope = previous
     end
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
     def merge!(rel)
       return self if rel.nil?
       MULTI_VALUE_METHODS.each do |method|
@@ -193,57 +222,13 @@ module Influxer
 
       self
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
     protected
 
-    def build_where(args, hargs, negate)
-      case
-      when (args.present? && 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)
-      if negate
-        "#{key}<#{quoted(val.begin)} and #{key}>#{quoted(val.end)}"
-      else
-        "#{key}>#{quoted(val.begin)} and #{key}<#{quoted(val.end)}"
-      end
+    def build_series_name
+      @instance.series
     end
 
     def loaded?
@@ -263,8 +248,8 @@ module Influxer
       self
     end
 
-    def quoted(val)
-      if val.is_a?(String) || val.is_a?(Symbol)
+    def quoted(val, key = nil)
+      if val.is_a?(String) || val.is_a?(Symbol) || @klass.tag?(key)
         "'#{val}'"
       elsif val.is_a?(Time) || val.is_a?(DateTime)
         "#{val.to_i}s"
@@ -273,9 +258,15 @@ module Influxer
       end
     end
 
-    def get_points(hash)
-      prepare_fanout_points(hash) if @values[:has_fanout] == true
-      hash.values.reduce([], :+)
+    def get_points(list)
+      return list if normalized?
+      list.reduce([]) do |a, e|
+        a + e.fetch("values", []).map { |v| inject_tags(v, e["tags"] || {}) }
+      end
+    end
+
+    def inject_tags(val, tags)
+      val.merge(tags)
     end
 
     def method_missing(method, *args, &block)

data/lib/influxer/metrics/scoping.rb

@@ -3,6 +3,7 @@ require 'influxer/metrics/scoping/default'
 require 'influxer/metrics/scoping/named'
 
 module Influxer
+  # Clone of ActiveRecord::Relation scoping
   module Scoping # :nodoc:
     extend ActiveSupport::Concern
 
@@ -47,10 +48,9 @@ module Influxer
       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
+        return if VALID_SCOPE_TYPES.include?(scope_type)
+        fail ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. \
+        Scope types  must be included in VALID_SCOPE_TYPES"
       end
     end
   end

data/lib/influxer/model.rb

@@ -6,6 +6,10 @@ module Influxer
     extend ActiveSupport::Concern
 
     module ClassMethods # :nodoc:
+      # rubocop:disable Style/PredicateName
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
       def has_metrics(*args, **params)
         metrics_name = args.empty? ? "metrics" : args.first.to_s
 

data/lib/influxer/rails/client.rb

@@ -0,0 +1,47 @@
+module Influxer
+  # - Overriding loggging (use instrumentation and Rails logger)
+  # - Add cache support for queries
+  class Client
+    def query(sql, options = {})
+      log(sql) do
+        if !options.fetch(:cache, true) || Influxer.config.cache == false
+          super(sql, options)
+        else
+          Rails.cache.fetch(normalized_cache_key(sql), cache_options(sql)) { super(sql, options) }
+        end
+      end
+    end
+
+    def log(sql)
+      return yield unless logger.debug?
+
+      start_ts = Time.now
+      res = yield
+      duration = (Time.now - start_ts) * 1000
+
+      name  = "InfluxDB SQL (#{duration.round(1)}ms)"
+
+      # bold black name and blue query string
+      msg = "\e[1m\e[30m#{name}\e[0m  \e[34m#{sql}\e[0m"
+      logger.debug msg
+      res
+    end
+
+    # if sql contains 'now()' set expires to 1 minute or :cache_now_for value
+    # of config.cache if defined
+    def cache_options(sql = nil)
+      options = Influxer.config.cache.dup
+      options[:expires_in] = (options[:cache_now_for] || 60) if sql =~ /\snow\(\)/
+      options
+    end
+
+    # add prefix; remove whitespaces
+    def normalized_cache_key(sql)
+      "influxer:#{sql.gsub(/\s*/, '')}"
+    end
+
+    def logger
+      Rails.logger
+    end
+  end
+end

data/lib/influxer/version.rb

@@ -1,3 +1,3 @@
 module Influxer # :nodoc:
-  VERSION = "0.2.4"
+  VERSION = "0.3.1"
 end

data/lib/influxer.rb

@@ -10,7 +10,8 @@ module Influxer
     require 'influxer/model'
   end
 
-  require 'influxer/engine'
+  require 'influxer/rails/client' if defined?(Rails)
+  require 'influxer/engine' if defined?(Rails)
 
   def self.config
     @config ||= Config.new
@@ -24,7 +25,8 @@ module Influxer
     @client ||= Client.new
   end
 
-  def self.reset
+  def self.reset!
+    @client.stop! unless @client.nil?
     @config = nil
     @client = nil
   end

data/spec/cases/points_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe DummyMetrics do
+  before do
+    stub_request(:get, "http://localhost:8086/query")
+      .with(
+        query: { q: 'select * from "dummy"', u: "root", p: "root", precision: 's', db: 'db' }
+      )
+      .to_return(body: fixture_file)
+  end
+
+  context "single_series" do
+    let(:fixture_file) { File.read('./spec/fixtures/single_series.json') }
+
+    context "default format (values merged with tags)" do
+      subject { described_class.all.to_a }
+
+      it "returns array of hashes" do
+        expect(subject.first).to include("host" => "server01", "region" => "us-west", "value" => 0.64)
+        expect(subject.second).to include("host" => "server01", "region" => "us-west", "value" => 0.93)
+      end
+    end
+  end
+
+  context "empty result" do
+    let(:fixture_file) { File.read('./spec/fixtures/empty_result.json') }
+
+    subject { described_class.all.to_a }
+
+    it "returns empty array" do
+      expect(subject).to eq []
+    end
+  end
+end

data/spec/client_spec.rb

@@ -1,46 +1,43 @@
 require 'spec_helper'
 
 describe Influxer::Client do
-  after(:each) do
-    Rails.cache.clear
-  end
-
   let(:conf) { Influxer.config }
-  let(:client) { Influxer.client }
+  subject { Influxer.client }
 
-  it "should have config params" do
-    expect(client.username).to eq conf.username
-    expect(client.port).to eq conf.port
-    expect(client.database).to eq conf.database
-  end
+  describe "#initialize" do
+    it "sets config database value" do
+      expect(subject.config.database).to eq conf.database
+    end
 
-  describe "cache" do
-    before do
-      allow_any_instance_of(Influxer::Client).to receive(:query) do |_, sql|
-        sql
-      end
+    it "passes config params" do
+      conf.username = 'admin'
+      conf.port = 2222
+      expect(subject.config.username).to eq 'admin'
+      expect(subject.config.port).to eq 2222
     end
+  end
 
+  describe "cache", :query do
     let(:q) { "list series" }
+    after { Rails.cache.clear }
 
-    after(:each) do
-      conf.cache = false
-    end
-
-    it "should write data to cache" do
+    it "writes data to cache" do
       conf.cache = {}
 
-      client.cached_query(q)
+      subject.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 }
+      conf.cache = { expires_in: 90 }
+
+      subject.query(q)
+      expect(Rails.cache.exist?("influxer:listseries")).to be_truthy
 
-      client.cached_query(q)
+      Timecop.travel(1.minute.from_now)
       expect(Rails.cache.exist?("influxer:listseries")).to be_truthy
 
-      sleep 2
+      Timecop.travel(2.minutes.from_now)
       expect(Rails.cache.exist?("influxer:listseries")).to be_falsey
     end
   end

data/spec/fixtures/empty_result.json

@@ -0,0 +1,21 @@
+{
+    "results": [
+        {
+            "series": [
+                {
+                    "name": "cpu_load_short",
+                    "tags": {
+                        "host": "server01",
+                        "region": "us-west"
+                    },
+                    "columns": [
+                        "time",
+                        "value"
+                    ],
+                    "values": [
+                    ]
+                }
+            ]
+        }
+    ]
+}

data/spec/fixtures/single_series.json

@@ -0,0 +1,29 @@
+{
+    "results": [
+        {
+            "series": [
+                {
+                    "name": "cpu_load_short",
+                    "tags": {
+                        "host": "server01",
+                        "region": "us-west"
+                    },
+                    "columns": [
+                        "time",
+                        "value"
+                    ],
+                    "values": [
+                        [
+                            "2015-01-29T21:51:28.968422294Z",
+                            0.64
+                        ],
+                        [
+                            "2015-01-29T21:51:38.968422294Z",
+                            0.93
+                        ]
+                    ]
+                }
+            ]
+        }
+    ]
+}