ruby-druid 0.9.0 → 0.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 804e71f527f98f4bc082a2967da5ce7065fa2c01
-  data.tar.gz: ada587e143c21e913df7386ebb3020155d82ff5d
+SHA256:
+  metadata.gz: 5c242b82f9ca73bc79a18d0fed69b6f956f515900c363bd7878b53f10eaad62d
+  data.tar.gz: e1699daefede54f60a9ac0e2be9b175b8d6dfd356c4550a36421933bd3e57866
 SHA512:
-  metadata.gz: be6eb7e1e566340d22c70b7bc693e3849260b9994886249b501d90db10fcbfac1b0074928e7e5118cc704b5b8eaeda5c02e8e24b3a6b05b0a03e31137090929e
-  data.tar.gz: 08d4a836a5ebc98cbd8c923a1ab718b9c67cceaa66be5e2ab218e85c2928564f47ed05ad2648a977b079f1691c96c35e273bf70494a5c50d9944636218e668fd
+  metadata.gz: c9e438973e1a8816ebbd293a409aafbad9c015a29ffa93a55826bf4c13c741f223eb30597e059f7b35357941f818cdba791a9337ea0cb0833c45c6fd7a9a5842
+  data.tar.gz: 5ac8395f4155f4c830bf6518e292a4fc7a7ce9b54df8337931072e5cd49409c1a54d739182ce82f6a148fcd040c8c3c0dde772d06ff192a0605363d27408cdfa

data/README.md

@@ -29,32 +29,22 @@ gem install ruby-druid
 
 ## Usage
 
-```ruby
-Druid::Client.new('zk1:2181,zk2:2181/druid').query('service/source')
-```
-
-returns a query object on which all other methods can be called to create a full and valid Druid query.
-
-A query object can be sent like this:
+A query can be constructed and sent like so:
 
 ```ruby
-client = Druid::Client.new('zk1:2181,zk2:2181/druid')
-query = Druid::Query.new('service/source')
-client.send(query)
+data_source = Druid::Client.new('zk1:2181,zk2:2181/druid').data_source('service/source')
+query = Druid::Query::Builder.new.long_sum(:aggregate1).last(1.day).granularity(:all)
+result = data_source.post(query)
 ```
 
-The `send` method returns the parsed response from the druid server as an array.  If the response is not empty it contains one `ResponseRow` object for each row.  The timestamp by can be received by a method with the same name (i.e. `row.timestamp`), all row values by hashlike syntax (i.e. `row['dimension'])
+The `post` method on the `DataSource` returns the parsed response from the Druid server as an array.
 
-An options hash can be passed when creating `Druid::Client` instance:
+If you don't want to use ZooKeeper for broker discovery, you can explicitly construct a `DataSource`:
 
 ```ruby
-client = Druid::Client.new('zk1:2181,zk2:2181/druid', http_timeout: 20)
+data_source = Druid::DataSource.new('service/source', 'http://localhost:8080/druid/v2')
 ```
 
-Supported options are:
-* `static_setup` to explicitly specify a broker url, e.g. `static_setup: { 'my/source_name' => 'http://1.2.3.4:8080/druid/v2/' }`
-* `http_timeout` to define a timeout for sending http queries to a broker (in minutes, default value is 2)
-
 ### GroupBy
 
 A [GroupByQuery](http://druid.io/docs/latest/querying/groupbyquery.html) sets the
@@ -63,7 +53,7 @@ dimensions to group the data.
 `queryType` is set automatically to `groupBy`.
 
 ```ruby
-Druid::Query.new('service/source').group_by([:dimension1, :dimension2])
+Druid::Query::Builder.new.group_by([:dimension1, :dimension2])
 ```
 
 ### TimeSeries
@@ -71,7 +61,7 @@ Druid::Query.new('service/source').group_by([:dimension1, :dimension2])
 A [TimeSeriesQuery](http://druid.io/docs/latest/querying/timeseriesquery.html) returns an array of JSON objects where each object represents a value asked for by the timeseries query.
 
 ```ruby
-Druid::Query.new('service/source').time_series([:aggregate1, :aggregate2])
+Druid::Query::Builder.new.time_series([:aggregate1, :aggregate2])
 ```
 
 ### Aggregations
@@ -79,7 +69,7 @@ Druid::Query.new('service/source').time_series([:aggregate1, :aggregate2])
 #### longSum, doubleSum, count, min, max, hyperUnique
 
 ```ruby
-Druid::Query.new('service/source').long_sum([:aggregate1, :aggregate2])
+Druid::Query::Builder.new.long_sum([:aggregate1, :aggregate2])
 ```
 
 In the same way could be used the following methods for [aggregations](http://druid.io/docs/latest/querying/aggregations.html) adding: `double_sum, count, min, max, hyper_unique`
@@ -87,7 +77,7 @@ In the same way could be used the following methods for [aggregations](http://dr
 #### cardinality
 
 ```ruby
-Druid::Query.new('service/source').cardinality(:aggregate, [:dimension1, dimension2], <by_row: true | false>)
+Druid::Query::Builder.new.cardinality(:aggregate, [:dimension1, dimension2], <by_row: true | false>)
 ```
 
 #### javascript
@@ -95,19 +85,29 @@ Druid::Query.new('service/source').cardinality(:aggregate, [:dimension1, dimensi
 For example calculation for `sum(log(x)/y) + 10`:
 
 ```ruby
-Druid::Query.new('service/source').js_aggregation(:aggregate, [:x, :y],
+Druid::Query::Builder.new.js_aggregation(:aggregate, [:x, :y],
   aggregate: "function(current, a, b)      { return current + (Math.log(a) * b); }",
   combine:   "function(partialA, partialB) { return partialA + partialB; }",
   reset:     "function()                   { return 10; }"
 )
 ```
 
+#### filtered aggregation
+
+A filtered aggregator wraps any given aggregator, but only aggregates the values for which the given dimension filter matches.
+
+```ruby
+Druid::Query::Builder.new.filtered_aggregation(:aggregate1, :aggregate_1_name, :longSum) do
+  dimension1.neq 1 & dimension2.neq 2
+end
+```
+
 ### Post Aggregations
 
 A simple syntax for post aggregations with +,-,/,* can be used like:
 
 ```ruby
-query = Druid::Query.new('service/source').long_sum([:aggregate1, :aggregate2])
+query = Druid::Query::Builder.new.long_sum([:aggregate1, :aggregate2])
 query.postagg { (aggregate2 + aggregate2).as output_field_name }
 ```
 
@@ -124,7 +124,7 @@ query.postagg { js('function(aggregate1, aggregate2) { return aggregate1 + aggre
 The interval for the query takes a string with date and time or objects that provide an `iso8601` method.
 
 ```ruby
-query = Druid::Query.new('service/source').long_sum(:aggregate1)
+query = Druid::Query::Builder.new.long_sum(:aggregate1)
 query.interval("2013-01-01T00", Time.now)
 ```
 
@@ -139,14 +139,14 @@ The period `'day'` or `:day` will be interpreted as `'P1D'`.
 If a period granularity is specifed, the (optional) second parameter is a time zone. It defaults to the machines local time zone. i.e.
 
 ```ruby
-query = Druid::Query.new('service/source').long_sum(:aggregate1)
+query = Druid::Query::Builder.new.long_sum(:aggregate1)
 query.granularity(:day)
 ```
 
 is (on my box) the same as
 
 ```ruby
-query = Druid::Query.new('service/source').long_sum(:aggregate1)
+query = Druid::Query::Builder.new.long_sum(:aggregate1)
 query.granularity('P1D', 'Europe/Berlin')
 ```
 
@@ -154,18 +154,18 @@ query.granularity('P1D', 'Europe/Berlin')
 
 ```ruby
 # equality
-Druid::Query.new('service/source').having { metric == 10 }
+Druid::Query::Builder.new.having { metric == 10 }
 ```
 
 ```ruby
 # inequality
-Druid::Query.new('service/source').having { metric != 10 }
+Druid::Query::Builder.new.having { metric != 10 }
 ```
 
 ```ruby
 # greater, less
-Druid::Query.new('service/source').having { metric > 10 }
-Druid::Query.new('service/source').having { metric < 10 }
+Druid::Query::Builder.new.having { metric > 10 }
+Druid::Query::Builder.new.having { metric < 10 }
 ```
 
 #### Compound having filters
@@ -174,17 +174,17 @@ Having filters can be combined with boolean logic.
 
 ```ruby
 # and
-Druid::Query.new('service/source').having { (metric != 1) & (metric2 != 2) }
+Druid::Query::Builder.new.having { (metric != 1) & (metric2 != 2) }
 ```
 
 ```ruby
 # or
-Druid::Query.new('service/source').having { (metric == 1) | (metric2 == 2) }
+Druid::Query::Builder.new.having { (metric == 1) | (metric2 == 2) }
 ```
 
 ```ruby
 # not
-Druid::Query.new('service/source').having{ !metric.eq(1) }
+Druid::Query::Builder.new.having{ !metric.eq(1) }
 ```
 
 ### Filters
@@ -197,27 +197,27 @@ Filters can be chained `filter{...}.filter{...}`
 
 ```ruby
 # equality
-Druid::Query.new('service/source').filter{dimension.eq 1}
-Druid::Query.new('service/source').filter{dimension == 1}
+Druid::Query::Builder.new.filter{dimension.eq 1}
+Druid::Query::Builder.new.filter{dimension == 1}
 ```
 
 ```ruby
 # inequality
-Druid::Query.new('service/source').filter{dimension.neq 1}
-Druid::Query.new('service/source').filter{dimension != 1}
+Druid::Query::Builder.new.filter{dimension.neq 1}
+Druid::Query::Builder.new.filter{dimension != 1}
 ```
 
 ```ruby
 # greater, less
-Druid::Query.new('service/source').filter{dimension > 1}
-Druid::Query.new('service/source').filter{dimension >= 1}
-Druid::Query.new('service/source').filter{dimension < 1}
-Druid::Query.new('service/source').filter{dimension <= 1}
+Druid::Query::Builder.new.filter{dimension > 1}
+Druid::Query::Builder.new.filter{dimension >= 1}
+Druid::Query::Builder.new.filter{dimension < 1}
+Druid::Query::Builder.new.filter{dimension <= 1}
 ```
 
 ```ruby
 # JavaScript
-Druid::Query.new('service/source').filter{a.javascript('dimension >= 1 && dimension < 5')}
+Druid::Query::Builder.new.filter{a.javascript('dimension >= 1 && dimension < 5')}
 ```
 
 #### Compound Filters
@@ -226,17 +226,17 @@ Filters can be combined with boolean logic.
 
 ```ruby
 # and
-Druid::Query.new('service/source').filter{dimension.neq 1 & dimension2.neq 2}
+Druid::Query::Builder.new.filter{dimension.neq 1 & dimension2.neq 2}
 ```
 
 ```ruby
 # or
-Druid::Query.new('service/source').filter{dimension.neq 1 | dimension2.neq 2}
+Druid::Query::Builder.new.filter{dimension.neq 1 | dimension2.neq 2}
 ```
 
 ```ruby
 # not
-Druid::Query.new('service/source').filter{!dimension.eq(1)}
+Druid::Query::Builder.new.filter{!dimension.eq(1)}
 ```
 
 #### Inclusion Filter
@@ -244,18 +244,18 @@ Druid::Query.new('service/source').filter{!dimension.eq(1)}
 This filter creates a set of equals filters in an or filter.
 
 ```ruby
-Druid::Query.new('service/source').filter{dimension.in(1,2,3)}
+Druid::Query::Builder.new.filter{dimension.in(1,2,3)}
 ```
 #### Geographic filter
 
 These filters have to be combined with time_series and do only work when coordinates is a spatial dimension [GeographicQueries](http://druid.io/docs/latest/development/geo.html)
 
 ```ruby
-Druid::Query.new('service/source').time_series().long_sum([:aggregate1]).filter{coordinates.in_rec [[50.0,13.0],[54.0,15.0]]}
+Druid::Query::Builder.new.time_series().long_sum([:aggregate1]).filter{coordinates.in_rec [[50.0,13.0],[54.0,15.0]]}
 ```
 
 ```ruby
-Druid::Query.new('service/source').time_series().long_sum([:aggregate1]).filter{coordinates.in_circ [[53.0,13.0], 5.0]}
+Druid::Query::Builder.new.time_series().long_sum([:aggregate1]).filter{coordinates.in_circ [[53.0,13.0], 5.0]}
 ```
 
 #### Exclusion Filter
@@ -263,7 +263,7 @@ Druid::Query.new('service/source').time_series().long_sum([:aggregate1]).filter{
 This filter creates a set of not-equals fitlers in an and filter.
 
 ```ruby
-Druid::Query.new('service/source').filter{dimension.nin(1,2,3)}
+Druid::Query::Builder.new.filter{dimension.nin(1,2,3)}
 ```
 
 #### Hash syntax
@@ -271,9 +271,9 @@ Druid::Query.new('service/source').filter{dimension.nin(1,2,3)}
 Sometimes it can be useful to use a hash syntax for filtering for example if you already get them from a list or parameter hash.
 
 ```ruby
-Druid::Query.new('service/source').filter{dimension => 1, dimension1 =>2, dimension2 => 3}
+Druid::Query::Builder.new.filter{dimension => 1, dimension1 =>2, dimension2 => 3}
 # which is equivalent to
-Druid::Query.new('service/source').filter{dimension.eq(1) & dimension1.eq(2) & dimension2.eq(3)}
+Druid::Query::Builder.new.filter{dimension.eq(1) & dimension1.eq(2) & dimension2.eq(3)}
 ```
 
 ## Contributing

data/lib/druid/aggregation.rb

@@ -59,6 +59,34 @@ module Druid
     attr_accessor :byRow
     validates :byRow, allow_nil: true, inclusion: { in: [true, false] }
 
+    class FilterValidator < ActiveModel::EachValidator
+      TYPES = %w[filtered].freeze
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          record.errors.add(attribute, 'may not be blank') if value.blank?
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
+      end
+    end
+
+    attr_accessor :filter
+    validates :filter, filter: true
+
+    class AggregatorValidator < ActiveModel::EachValidator
+      TYPES = %w[filtered].freeze
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          record.errors.add(attribute, 'may not be blank') if value.blank?
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
+      end
+    end
+
+    attr_accessor :aggregator
+    validates :aggregator, aggregator: true
+
     def as_json(options = {})
       super(options.merge(except: %w(errors validation_context)))
     end

data/lib/druid/data_source.rb

@@ -74,22 +74,49 @@ module Druid
           return self.post(query)
         end
 
-        raise Error.new(response), "request failed"
+        raise Error.new(response)
       end
 
       MultiJson.load(response.body)
     end
 
     class Error < StandardError
-      attr_reader :response
+      attr_reader :error, :error_message, :error_class, :host, :response
+
       def initialize(response)
         @response = response
+        parsed_body = MultiJson.load(response.body)
+        @error, @error_message, @error_class, @host = parsed_body.values_at(*%w(
+          error
+          errorMessage
+          errorClass
+          host
+        ))
       end
 
       def message
-        MultiJson.load(response.body)["error"]
+        error
+      end
+
+      def query_timeout?
+        error == 'Query timeout'.freeze
+      end
+
+      def query_interrupted?
+        error == 'Query interrupted'.freeze
       end
-    end
 
+      def query_cancelled?
+        error == 'Query cancelled'.freeze
+      end
+
+      def resource_limit_exceeded?
+        error == 'Resource limit exceeded'.freeze
+      end
+
+      def unknown_exception?
+        error == 'Unknown exception'.freeze
+      end
+    end
   end
 end

data/lib/druid/dimension.rb

@@ -0,0 +1,54 @@
+module Druid
+  class Dimension
+    include ActiveModel::Model
+
+    attr_accessor :type
+    validates :type, inclusion: { in: %w(default extraction) }
+
+    attr_accessor :dimension
+    validates :dimension, presence: true
+
+    attr_accessor :outputName
+    validates :outputName, presence: true
+
+    class ExtractionFnValidator < ActiveModel::EachValidator
+      TYPES = %w(extraction)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.type)
+          record.errors.add(attribute, 'may not be blank') if value.blank?
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.type}") if value
+        end
+      end
+    end
+
+    attr_accessor :extractionFn
+    validates :extractionFn, extraction_fn: true
+
+    def initialize(params)
+      if params.is_a?(Hash)
+        super
+      else
+        super(type: 'default', dimension: params.to_s, outputName: params.to_s)
+      end
+    end
+
+    def as_json(options = {})
+      super(options.merge(except: %w(errors validation_context)))
+    end
+
+    def self.lookup(dimension, namespace, outputName: nil, retain: true, injective: false)
+      new({
+        type: 'extraction',
+        dimension: dimension,
+        outputName: outputName || namespace,
+        extractionFn: {
+          type: 'registeredLookup',
+          lookup: namespace,
+          retainMissingValue: retain,
+          injective: injective,
+        },
+      })
+    end
+  end
+end

data/lib/druid/filter.rb

@@ -166,6 +166,14 @@ module Druid
       CircFilter.new(@dimension, bounds)
     end
 
+    def bound(params)
+      BoundFilter.new(@dimension, params)
+    end
+
+    def search(params)
+      SearchFilter.new(@dimension, params)
+    end
+
     def eq(value)
       case value
       when ::Array
@@ -299,7 +307,35 @@ module Druid
       @bound = {
         type: 'radius',
         coords: bounds.first,
-        radius: bounds.last,
+        radius: bounds.last
+      }
+    end
+  end
+
+  class BoundFilter < Filter
+    include BooleanOperators
+
+    def initialize(dimension, params)
+      super()
+      @type = 'bound'
+      @dimension = dimension
+      @ordering = params[:ordering]
+      @upper = params[:upper]
+      @upperStrict = params[:upperStrict]
+    end
+  end
+
+  class SearchFilter < Filter
+    include BooleanOperators
+
+    def initialize(dimension, params)
+      super()
+      @type = 'search'
+      @dimension = dimension
+      @query = {
+        type: 'contains',
+        value: params[:value],
+        caseSensitive: params[:case_sensitive] || false
       }
     end
   end

data/lib/druid/query.rb

@@ -5,6 +5,7 @@ require 'active_support/all'
 require 'active_model'
 
 require 'druid/granularity'
+require 'druid/dimension'
 require 'druid/aggregation'
 require 'druid/post_aggregation'
 require 'druid/filter'
@@ -80,7 +81,16 @@ module Druid
       TYPES = %w(groupBy select)
       def validate_each(record, attribute, value)
         if TYPES.include?(record.queryType)
-          record.errors.add(attribute, 'must be a list with at least one dimension') if !value.is_a?(Array) || value.blank?
+          if !value.is_a?(Array) || value.blank?
+            record.errors.add(attribute, 'must be a list with at least one dimension')
+          else
+            value.each(&:valid?) # trigger validation
+            value.each do |avalue|
+              avalue.errors.messages.each do |k, v|
+                record.errors.add(attribute, { k => v })
+              end
+            end
+          end
         else
           record.errors.add(attribute, "is not supported by type=#{record.queryType}") if value
         end
@@ -90,14 +100,34 @@ module Druid
     attr_accessor :dimensions
     validates :dimensions, dimensions: true
 
+    def dimensions
+      @dimensions ||= []
+    end
+
+    def dimensions=(value)
+      if value.is_a?(Array)
+        @dimensions = value.map do |x|
+          x.is_a?(Dimension) ? x : Dimension.new(x)
+        end
+      else
+        @dimensions = [
+          value.is_a?(Dimension) ? value : Dimension.new(value)
+        ]
+      end
+    end
+
     class AggregationsValidator < ActiveModel::EachValidator
       TYPES = %w(timeseries groupBy topN)
       def validate_each(record, attribute, value)
         if TYPES.include?(record.queryType)
-          value.each(&:valid?) # trigger validation
-          value.each do |avalue|
-            avalue.errors.messages.each do |k, v|
-              record.errors.add(attribute, { k => v })
+          if !value.is_a?(Array) || value.blank?
+            record.errors.add(attribute, 'must be a list with at least one aggregator')
+          else
+            value.each(&:valid?) # trigger validation
+            value.each do |avalue|
+              avalue.errors.messages.each do |k, v|
+                record.errors.add(attribute, { k => v })
+              end
             end
           end
         else
@@ -116,10 +146,12 @@ module Druid
     def aggregations=(value)
       if value.is_a?(Array)
         @aggregations = value.map do |x|
-          Aggregation.new(x)
+          x.is_a?(Aggregation) ? x : Aggregation.new(x)
         end
       else
-        @aggregations = [value]
+        @aggregations = [
+          value.is_a?(Aggregation) ? value : Aggregation.new(value)
+        ]
       end
     end
 
@@ -333,7 +365,9 @@ module Druid
 
       def group_by(*dimensions)
         query_type(:groupBy)
-        @query.dimensions = dimensions.flatten
+        @query.dimensions = dimensions.flatten.map do |dimension|
+          dimension.is_a?(Dimension) ? dimension : Dimension.new(dimension)
+        end
         self
       end
 
@@ -417,6 +451,19 @@ module Druid
         self
       end
 
+      def filtered_aggregation(metric, name, aggregation_type, &filter)
+        @query.aggregations << Aggregation.new(
+          type: 'filtered',
+          filter: Filter.new.instance_exec(&filter),
+          aggregator: Aggregation.new(
+            type: aggregation_type.to_s.camelize(:lower),
+            name: name,
+            fieldName: metric
+          )
+        ) unless @query.contains_aggregation?(name)
+        self
+      end
+
       ## post aggregations
 
       def postagg(type = :long_sum, &block)

data/lib/druid/version.rb

@@ -1,3 +1,3 @@
 module Druid
-  VERSION = "0.9.0"
+  VERSION = '0.11.2'
 end

data/lib/druid/zk.rb

@@ -13,37 +13,37 @@ module Druid
     end
 
     def register
-      $log.info("druid.zk register discovery path") if $log
+      $log.debug("druid.zk register discovery path") if $log
       @zk.on_expired_session { register }
       @zk.register(@discovery_path, only: :child) do |event|
-        $log.info("druid.zk got event on discovery path") if $log
+        $log.debug("druid.zk got event on discovery path") if $log
         check_services
       end
       check_services
     end
 
     def close!
-      $log.info("druid.zk shutting down") if $log
+      $log.debug("druid.zk shutting down") if $log
       @zk.close!
     end
 
     def register_service(service, brokers)
-      $log.info("druid.zk register", service: service, brokers: brokers) if $log
+      $log.debug("druid.zk register", service: service, brokers: brokers) if $log
       # poor mans load balancing
       @registry[service] = brokers.shuffle
     end
 
     def unregister_service(service)
-      $log.info("druid.zk unregister", service: service) if $log
+      $log.debug("druid.zk unregister", service: service) if $log
       @registry.delete(service)
       unwatch_service(service)
     end
 
     def watch_service(service)
       return if @watched_services.include?(service)
-      $log.info("druid.zk watch", service: service) if $log
+      $log.debug("druid.zk watch", service: service) if $log
       watch = @zk.register(watch_path(service), only: :child) do |event|
-        $log.info("druid.zk got event on watch path for", service: service, event: event) if $log
+        $log.debug("druid.zk got event on watch path for", service: service, event: event) if $log
         unwatch_service(service)
         check_service(service)
       end
@@ -52,12 +52,12 @@ module Druid
 
     def unwatch_service(service)
       return unless @watched_services.include?(service)
-      $log.info("druid.zk unwatch", service: service) if $log
+      $log.debug("druid.zk unwatch", service: service) if $log
       @watched_services.delete(service).unregister
     end
 
     def check_services
-      $log.info("druid.zk checking services") if $log
+      $log.debug("druid.zk checking services") if $log
       zk_services = @zk.children(@discovery_path, watch: true)
 
       (services - zk_services).each do |service|
@@ -70,7 +70,7 @@ module Druid
     end
 
     def verify_broker(service, name)
-      $log.info("druid.zk verify", broker: name, service: service) if $log
+      $log.debug("druid.zk verify", broker: name, service: service) if $log
       info = @zk.get("#{watch_path(service)}/#{name}")
       node = MultiJson.load(info[0])
       uri = "http://#{node['address']}:#{node['port']}/druid/v2/"
@@ -78,7 +78,7 @@ module Druid
         method: :get, url: "#{uri}datasources/",
         timeout: 5, open_timeout: 5
       })
-      $log.info("druid.zk verified", uri: uri, sources: check) if $log
+      $log.debug("druid.zk verified", uri: uri, sources: check) if $log
       return [uri, MultiJson.load(check.to_str)] if check.code == 200
     rescue
       return false
@@ -96,7 +96,7 @@ module Druid
       known = @registry[service].map { |node| node[:name] }
       live = @zk.children(watch_path(service), watch: true)
       new_list = @registry[service].select { |node| live.include?(node[:name]) }
-      $log.info("druid.zk checking", service: service, known: known, live: live, new_list: new_list) if $log
+      $log.debug("druid.zk checking", service: service, known: known, live: live, new_list: new_list) if $log
 
       # verify the new entries to be living brokers
       (live - known).each do |name|

data/ruby-druid.gemspec

@@ -19,13 +19,13 @@ Gem::Specification.new do |spec|
   spec.test_files = Dir["spec/**/*"]
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activesupport", "~> 4.2"
-  spec.add_dependency "activemodel", "~> 4.2"
-  spec.add_dependency "iso8601", "~> 0.9"
-  spec.add_dependency "multi_json", "~> 1.12"
-  spec.add_dependency "rest-client", "~> 2.0"
+  spec.add_dependency "activesupport", ">= 3.0.0"
+  spec.add_dependency "activemodel", ">= 3.0.0"
+  spec.add_dependency "iso8601", "~> 0.8"
+  spec.add_dependency "multi_json", "~> 1.0"
+  spec.add_dependency "rest-client", ">= 1.8", "< 3.0"
   spec.add_dependency "zk", "~> 1.9"
-  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "bundler", ">= 1.3.0", "< 2.2"
   spec.add_development_dependency "rake", "~> 11.2"
   spec.add_development_dependency "rspec", "~> 3.4"
   spec.add_development_dependency "webmock", "~> 2.1"

data/spec/lib/data_source_spec.rb

@@ -19,20 +19,35 @@ describe Druid::DataSource do
     end
 
     it 'raises on request failure' do
-      # MRI
-      stub_request(:post, 'http://www.example.com/druid/v2').
-        with(:body => "{\"context\":{\"queryId\":null},\"queryType\":\"timeseries\",\"intervals\":[\"2013-04-04T00:00:00+00:00/2013-04-04T00:00:00+00:00\"],\"granularity\":\"all\",\"dataSource\":\"test\"}",
-          :headers => { 'Accept' => '*/*', 'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Content-Type' => 'application/json', 'User-Agent' => 'Ruby' }).
-        to_return(:status => 666, :body => 'Strange server error', :headers => {})
-      # JRuby ... *sigh
-      stub_request(:post, 'http://www.example.com/druid/v2').
-        with(:body => "{\"context\":{\"queryId\":null},\"granularity\":\"all\",\"intervals\":[\"2013-04-04T00:00:00+00:00/2013-04-04T00:00:00+00:00\"],\"queryType\":\"timeseries\",\"dataSource\":\"test\"}",
-          :headers => { 'Accept' => '*/*', 'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Content-Type' => 'application/json', 'User-Agent' => 'Ruby' }).
-        to_return(:status => 666, :body => 'Strange server error', :headers => {})
+      stub_request(:post, 'http://www.example.com/druid/v2')
+        .with(
+          :body => %q({"context":{"queryId":null},"queryType":"timeseries","intervals":["2013-04-04T00:00:00+00:00/2013-04-04T00:00:00+00:00"],"granularity":"all","dataSource":"test"}),
+          :headers => {
+            'Accept' => '*/*',
+            'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+            'Content-Type' => 'application/json',
+            'User-Agent' => 'Ruby',
+          }
+        )
+        .to_return(
+          :status => 500,
+          :body => %q({"error":"Unknown exception","errorMessage":"NullPointerException","errorClass":"java.lang.NullPointerException","host":"www.example.com"}),
+          :headers => {},
+        )
+
       ds = Druid::DataSource.new('test/test', 'http://www.example.com/druid/v2')
       query = Druid::Query::Builder.new.interval('2013-04-04', '2013-04-04').granularity(:all).query
       query.context.queryId = nil
-      expect { ds.post(query) }.to raise_error(Druid::DataSource::Error)
+
+      expect { ds.post(query) }.to raise_error { |error|
+        expect(error).to be_a(Druid::DataSource::Error)
+        expect(error.message).to eq(error.error)
+        expect(error.error).to eq('Unknown exception')
+        expect(error.error_message).to eq('NullPointerException')
+        expect(error.error_class).to eq('java.lang.NullPointerException')
+        expect(error.host).to eq('www.example.com')
+        expect(error).to be_unknown_exception
+      }
     end
   end
 

data/spec/lib/query_spec.rb

@@ -21,7 +21,9 @@ describe Druid::Query do
 
   it 'takes dimensions from group_by method' do
     @query.group_by(:a, :b, :c)
-    expect(JSON.parse(@query.query.to_json)['dimensions']).to eq(['a', 'b', 'c'])
+    expect(JSON.parse(@query.query.to_json)['dimensions']).to eq([{"type"=>"default", "dimension"=>"a", "outputName"=>"a"},
+                                                                  {"type"=>"default", "dimension"=>"b", "outputName"=>"b"},
+                                                                  {"type"=>"default", "dimension"=>"c", "outputName"=>"c"}])
   end
 
   it 'takes dimension, metric and threshold from topn method' do
@@ -207,6 +209,32 @@ describe Druid::Query do
     end
   end
 
+  describe '#filtered_aggregation' do
+    it 'builds filtered aggregations' do
+      @query.filtered_aggregation(:a, :a_filtered, :longSum) do
+        b.eq(2) & c.neq(3)
+      end
+      expect(JSON.parse(@query.query.to_json)['aggregations']).to eq [
+        {
+          'type' => 'filtered',
+          'filter' => {
+            'type' => 'and',
+            'fields' => [
+              { 'dimension' => 'b', 'type' => 'selector', 'value' => 2 },
+              {
+                'type' => 'not',
+                'field' => {
+                  'dimension' => 'c', 'type' => 'selector', 'value' => 3
+                }
+              }
+            ]
+          },
+          'aggregator' => { 'type' => 'longSum', 'name' => 'a_filtered', 'fieldName' => 'a' }
+        }
+      ]
+    end
+  end
+
   it 'appends long_sum properties from aggregations on calling long_sum again' do
     @query.long_sum(:a, :b, :c)
     @query.double_sum(:x,:y)

metadata

@@ -1,85 +1,91 @@
 --- !ruby/object:Gem::Specification
 name: ruby-druid
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.11.2
 platform: ruby
 authors:
 - Ruby Druid Community
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-07-18 00:00:00.000000000 Z
+date: 2020-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: iso8601
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rest-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: zk
   requirement: !ruby/object:Gem::Requirement
@@ -98,16 +104,22 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -153,7 +165,7 @@ dependencies:
 description: |2
       ruby-druid is a Ruby client for Druid. It includes a Squeel-like query DSL
       and generates a JSON query that can be sent to Druid directly.
-email: 
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -165,6 +177,7 @@ files:
 - lib/druid/client.rb
 - lib/druid/context.rb
 - lib/druid/data_source.rb
+- lib/druid/dimension.rb
 - lib/druid/filter.rb
 - lib/druid/granularity.rb
 - lib/druid/having.rb
@@ -182,7 +195,7 @@ homepage: https://github.com/ruby-druid/ruby-druid
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -197,14 +210,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: A Ruby client for Druid
 test_files:
+- spec/spec_helper.rb
 - spec/lib/client_spec.rb
+- spec/lib/zk_spec.rb
 - spec/lib/data_source_spec.rb
 - spec/lib/query_spec.rb
-- spec/lib/zk_spec.rb
-- spec/spec_helper.rb