ruby-druid 0.10.0 → 0.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef87663c236bf89b7937fef4c7709d3937e5f0e6
-  data.tar.gz: 82d29a256a0cebc175aeb9d88173f1455e9a8475
+  metadata.gz: 50802fa6fd17c18928330f89aa8a9e8aa1b552c9
+  data.tar.gz: 52827d8bb44dc95de2335f9792ab79f211ed0ad0
 SHA512:
-  metadata.gz: a81d42c823310788cf35fcde9c683674fd863ea3f71557d1ab0e3c01d21f66cdeedd601a816deced10367b27db19d625fc19803d6463bfdaea3aa42f063f8875
-  data.tar.gz: 1a0c049e54420fc1c6773e489cbef4a118f751f4e5c9172377ace9474173dab10cba6d41253056e305e5c4156c02cc8594814f1138852ad7806272c249532583
+  metadata.gz: 9606e256ba1341ba5de30371eb5a65307506131be89ebff99cbc21e2546f5e692a8487b89ad8d410e8491cfc2980dec00a79476400e1091a8cf92247726ab0c2
+  data.tar.gz: 82a3948ec8332ff637ba32b0a981fb07fdce8efc7e44c5d59a5c37ca70d5cd27d406988bb8c74071936ac28ec3a3cbfeef07a5453cad2825796413e35db5c1f0

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,11 +271,18 @@ 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)}
 ```
 
+## Instrumentation
+
+Provides a single event `post.druid`. Payload:
+
+ - `data_source`
+ - `query`
+
 ## Contributing
 
 1. Fork it

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

@@ -59,12 +59,16 @@ module Druid
       query.dataSource = name
 
       req = Net::HTTP::Post.new(uri.path, { 'Content-Type' => 'application/json' })
-      req.body = query.to_json
+      query_as_json = query.as_json
+      req.body = MultiJson.dump(query_as_json)
 
-      response = Net::HTTP.new(uri.host, uri.port).start do |http|
-        http.open_timeout = 10 # if druid is down fail fast
-        http.read_timeout = nil # we wait until druid is finished
-        http.request(req)
+
+      response = ActiveSupport::Notifications.instrument('post.druid', data_source: name, query: query_as_json) do
+        Net::HTTP.new(uri.host, uri.port).start do |http|
+          http.open_timeout = 10 # if druid is down fail fast
+          http.read_timeout = nil # we wait until druid is finished
+          http.request(req)
+        end
       end
 
       if response.code != '200'
@@ -74,22 +78,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
+
+      def query_cancelled?
+        error == 'Query cancelled'.freeze
       end
-    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

@@ -37,11 +37,11 @@ module Druid
       super(options.merge(except: %w(errors validation_context)))
     end
 
-    def self.lookup(dimension, namespace, retain: true, injective: false)
+    def self.lookup(dimension, namespace, outputName: nil, retain: true, injective: false)
       new({
         type: 'extraction',
         dimension: dimension,
-        outputName: dimension,
+        outputName: outputName || namespace,
         extractionFn: {
           type: 'registeredLookup',
           lookup: namespace,

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

@@ -365,7 +365,7 @@ module Druid
 
       def group_by(*dimensions)
         query_type(:groupBy)
-        @query.dimensions = dimensions.map do |dimension|
+        @query.dimensions = dimensions.flatten.map do |dimension|
           dimension.is_a?(Dimension) ? dimension : Dimension.new(dimension)
         end
         self
@@ -451,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.10.0"
+  VERSION = '0.11.3'
 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

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   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.3.0", "< 2.0"
+  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

@@ -1,7 +1,8 @@
 describe Druid::DataSource do
 
   context '#post' do
-    it 'parses response on 200' do
+  context 'if the request is succesful' do
+    before 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\"}",
@@ -12,27 +13,55 @@ describe Druid::DataSource do
         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 => 200, :body => '[]', :headers => {})
+    end
+
+    it 'parses response on 200' do
       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 be_empty
     end
 
+    it 'instruments requests' do
+      expect(ActiveSupport::Notifications).to receive(:instrument).with('post.druid', data_source: 'test', query: instance_of(Hash)).and_call_original
+
+      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
+      ds.post(query)
+    end
+  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

@@ -209,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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-druid
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.3
 platform: ruby
 authors:
 - Ruby Druid Community
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-14 00:00:00.000000000 Z
+date: 2020-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -109,7 +109,7 @@ dependencies:
         version: 1.3.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -119,7 +119,7 @@ dependencies:
         version: 1.3.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -211,13 +211,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: A Ruby client for Druid
 test_files:
 - spec/spec_helper.rb
 - spec/lib/client_spec.rb
-- spec/lib/data_source_spec.rb
 - spec/lib/zk_spec.rb
+- spec/lib/data_source_spec.rb
 - spec/lib/query_spec.rb