ruby-druid 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef87663c236bf89b7937fef4c7709d3937e5f0e6
-  data.tar.gz: 82d29a256a0cebc175aeb9d88173f1455e9a8475
+  metadata.gz: 62a8990d73fd742e2fbe2eb50bea8e6867d86e76
+  data.tar.gz: 5e17079e581ecce9e6a013b3e1dd44c25b8c2555
 SHA512:
-  metadata.gz: a81d42c823310788cf35fcde9c683674fd863ea3f71557d1ab0e3c01d21f66cdeedd601a816deced10367b27db19d625fc19803d6463bfdaea3aa42f063f8875
-  data.tar.gz: 1a0c049e54420fc1c6773e489cbef4a118f751f4e5c9172377ace9474173dab10cba6d41253056e305e5c4156c02cc8594814f1138852ad7806272c249532583
+  metadata.gz: d08040c0aefb284858e323275fc86c18c7f99290f4463e6c309f172efa7086c43ff56d06869fe70c9563be423b86f6243ef203db06dcbaa9e4ade5515ff5328c
+  data.tar.gz: 3dcf38b1a373577940f2de02e44bf14252e09fc7a2c760f5c8be6d7d1e6b09c2f80412e4341491708759250e306ecf62ce8f5986db5468d5c87e6cd4a69db830

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,7 +85,7 @@ 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; }"
@@ -107,7 +97,7 @@ Druid::Query.new('service/source').js_aggregation(:aggregate, [:x, :y],
 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 +114,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 +129,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 +144,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 +164,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 +187,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 +216,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 +234,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 +253,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 +261,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/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

@@ -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/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

data/lib/druid/version.rb

@@ -1,3 +1,3 @@
 module Druid
-  VERSION = "0.10.0"
+  VERSION = '0.10.1'
 end

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
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-druid
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Ruby Druid Community
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-14 00:00:00.000000000 Z
+date: 2018-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -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