jruby-druid 1.0.0.pre.rc2 → 1.0.0.pre.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21e8d32e124615a4416d3c96d100dc5321aad913
-  data.tar.gz: 5d668c1de6018fe3d4e0fe0a8ab8150df5ebf89d
+  metadata.gz: 06409cebe3d3cd2cb703ddee8f02641ec595fefb
+  data.tar.gz: 0ca03f5b670a4d814d1d5d172b73376894558245
 SHA512:
-  metadata.gz: d8f6e25c91a4d162f4d1b463354cdc2baa55b41bebe0017097bf16752952bcb181912449237db0b25c9f2cfdf9249d63656796a45049b33361bf44010bd1b8a9
-  data.tar.gz: 2a4b4842a23fc82303c57b148a74a5b4a9d141c6fe6382c261cde2fe8945fffae45f295f1b07ddfd0704afc937fc3393639cf131d1c1a4778de07a178ebff376
+  metadata.gz: aa7f5e0373e4c546661f9cb6a0cd986e7caaf9b34176556fad06296f9348ea7068f581d6450c4adf5e4621ca567065184e4a6b96734d0747a07913fc3fefb845
+  data.tar.gz: 666e188bd7807760b11b9ca5c1eb1d50627fcb929501f77d53edda0472637e9d663eccd502f33a11b29a8538bac986f0250f406eac77d7351a67ad51516d6b9a

data/.travis.yml

@@ -1,4 +1,10 @@
 language: ruby
 rvm:
-  - 2.2.3
-before_install: gem install bundler -v 1.11.2
+  - jruby-1.7.19
+  - jruby-9.1.2.0
+jdk:
+  - openjdk7
+  - oraclejdk7
+  - oraclejdk8
+script:
+  - bundle exec rspec spec/druid/

data/Gemfile

@@ -1,2 +1,9 @@
 source 'https://rubygems.org'
+
+if JRUBY_VERSION.to_i < 9
+  gem 'activesupport', '~> 4.0'
+else
+  gem 'activesupport', '~> 5.0'
+end
+
 gemspec

data/README.md

@@ -1,9 +1,147 @@
-# JRuby Druid
+# jruby-druid
+[![Build Status](https://travis-ci.org/andremleblanc/jruby-druid.svg?branch=master)](https://travis-ci.org/andremleblanc/jruby-druid)
 
-This project is in active development.
+## Foreword
+This documentation is intended to be a quick-start guide, not a comprehensive
+list of all available methods and configuration options. Please look through
+the source for more information; a great place to get started is `Druid::Client`
+and the `Druid::Query` modules as they expose most of the methods on the client.
 
+Further, this guide assumes a significant knowledge of Druid, for more info:
+http://druid.io/docs/latest/design/index.html
+
+## Install
+
+```
+$ gem install jruby-druid
+```
+
+## Usage
+
+### Creating a Client
+```
+# With default configuration:
+client = Druid::Client.new
+```
+
+```
+# With custom tuning_granularity:
+client = Druid::Client.new(tuning_granularity: :hour)
+```
+*Note:* There are many configuration options, please take a look at
+`Druid::Configuration` for more details.
+
+### Administrative Tasks
+Creating a datasource is handled when writing points.
+
+Delete datasource(s):
+```
+# Delete a specific datasource:
+datasource_name = 'foo'
+client.delete_datasource(datasource_name)
+```
+
+```
+# Deleting all datasources:
+client.delete_datasources
+```
+
+*Note:* Deleting datasources and writing to them again can be a bit tricky in
+Druid. If this is something you need to do (like in testing) then you can use
+the strong_delete configuration option
+(`Druid::Client.new(strong_delete: true)`). This setting is not recommend for
+production since it uses randomizeTaskIds in the DruidBeamConfig which can lead
+to race conditions.
+
+List datasources:
+```
+client.list_datasources
+```
+
+Shutdown tasks:
+```
+client.shutdown_tasks
+```
+
+## Writing Data
+
+Write a datapoint:
+```
+datasource_name = 'foo'
+datapoint = {
+  timestamp: Time.now.utc, # Optional: Defaults to Time.now.utc
+  dimensions: { foo: 'bar' }, # Arbitrary key-value tags
+  metrics: { baz: 1 } # The values being measured
+}
+client.write_point(datasource_name, datapoint)
+```
+*Note:* The `write_point` utilizes the
+[Tranquility Core API](https://github.com/druid-io/tranquility/blob/master/docs/core.md)
+to communicate with Druid. The Tranquility API handles a lot of concerns like
+buffering, service discovery, schema rollover etc. The main features of
+the `write_point` method are 1) creation of the data schema and 2) detecting
+schema change to support automatic schema evolution.
+
+Basically, when you write a point with the `write_point` method, it will compare
+the point with the current schema (if present) and create a new Tranquilizer
+(connection to Druid) with the new schema if needed. This all happens
+seamlessly without your application needing to know anything about schema.
+
+The expectation is the schema changes infrequently and subsequent writes after
+a schema change have the same schema.
+
+## Reading Data
+
+Querying:
+```
+start_time = Time.now.utc.advance(days: -30)
+
+client.query(
+  queryType: 'timeseries',
+  dataSource: 'foo',
+  granularity: 'day',
+  intervals: start_time.iso8601 + '/' + Time.now.utc.iso8601,
+  aggregations: [{ type: 'longSum', name: 'baz', fieldName: 'baz' }]
+)
+```
+*Note:* The `query` method just POSTs the query to Druid; for information on
+querying Druid: http://druid.io/docs/latest/querying/querying.html. This is
+intentionally simple to allow all current features and hopefully all future
+features of the Druid query language without updating the gem.
+
+Fill Empty Intervals:
+
+Currently, Druid will not fill empty intervals for which there are no points. To
+accommodate this need until it is handled more efficiently in Druid, use the
+experimental `fill_value` feature in your query. This ensure you get an result
+for every interval in intervals.
+
+This has only been tested with 'timeseries' and single-dimension 'groupBy'
+queries with simple granularities.
+```
+start_time = Time.now.utc.advance(days: -30)
+
+client.query(
+  queryType: 'timeseries',
+  dataSource: 'foo',
+  granularity: 'day',
+  intervals: start_time.iso8601 + '/' + Time.now.utc.iso8601,
+  aggregations: [{ type: 'longSum', name: 'baz', fieldName: 'baz' }],
+  fill_value: 0
+)
+```
+
+## Testing
+
+The tests in `/spec/druid` can be run without Druid running. The tests in
+`/spec/integration` require Druid to be running.
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
 
+## Credit
+
+This project is somewhat modeled after the
+[influxdb-ruby](https://github.com/influxdata/influxdb-ruby) adapter, just
+wanted to give a shout out for their work.

data/benchmark.rb

@@ -5,6 +5,9 @@ require 'jruby-druid'
 @max = 100000
 # 100000 points | druid: 154.772s | influx: 246.821s
 # 100000 points | druid: 208.095s | influx: 244.993s - Schema Change Detection
+# 100000 points | druid: 391.063s | influx: 230.737 - 1.0.0-rc1
+# 100000 points | druid: 529.668s | influx: 500.526s - 1.0.0 - Handle ZK Connection
+# 100000 points | druid: 387.175s | influx: 433.34s - 1.0.0-rc3
 
 def run_druid_benchmark
 	attempts = 0

data/bin/console

@@ -3,12 +3,5 @@
 require "bundler/setup"
 require "jruby-druid"
 
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
 require "irb"
 IRB.start

data/jruby-druid.gemspec

@@ -19,10 +19,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib", "vendor"]
 
-  spec.add_dependency "activesupport", "~> 4.0"
-  spec.add_dependency "zk", "~> 1.9"
+  spec.add_dependency "activesupport"
 
-  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "faker", "~> 1.6"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"

data/lib/druid/client.rb

@@ -1,8 +1,9 @@
 module Druid
   class Client
-    include Druid::Query::Core
-    include Druid::Query::Datasource
-    include Druid::Query::Task
+    include Druid::Logging
+    include Druid::Queries::Core
+    include Druid::Queries::Datasource
+    include Druid::Queries::Task
 
     attr_reader :broker,
                 :config,
@@ -14,8 +15,15 @@ module Druid
       @config = Druid::Configuration.new(options)
       @broker = Druid::Node::Broker.new(config)
       @coordinator = Druid::Node::Coordinator.new(config)
+      setup_logger
       @overlord = Druid::Node::Overlord.new(config)
       @writer = Druid::Writer::Base.new(config)
     end
+
+    private
+
+    def setup_logger
+      logger.set_level(config.log_level)
+    end
   end
 end

data/lib/druid/configuration.rb

@@ -5,22 +5,26 @@ module Druid
     CURATOR_URI = 'localhost:2181'.freeze
     DISCOVERY_PATH = '/druid/discovery'.freeze
     INDEX_SERVICE = 'druid/overlord'.freeze
+    LOG_LEVEL = :warn
     OVERLORD_URI = 'http://localhost:8090/'.freeze
     ROLLUP_GRANULARITY = :minute
-    STRONG_DELETE = false
+    STRONG_DELETE = false # Not recommend to be true for production.
     TUNING_GRANULARITY = :day
     TUNING_WINDOW = 'PT1H'.freeze
+    WAIT_TIME = 20 # Seconds
 
     attr_reader :broker_uri,
                 :coordinator_uri,
                 :curator_uri,
                 :discovery_path,
                 :index_service,
+                :log_level,
                 :overlord_uri,
                 :rollup_granularity,
                 :strong_delete,
                 :tuning_granularity,
-                :tuning_window
+                :tuning_window,
+                :wait_time
 
 
     def initialize(opts = {})
@@ -29,11 +33,13 @@ module Druid
       @curator_uri = opts[:curator_uri] || CURATOR_URI
       @discovery_path = opts[:discovery_path] || DISCOVERY_PATH
       @index_service = opts[:index_service] || INDEX_SERVICE
+      @log_level = opts[:log_level] || LOG_LEVEL
       @overlord_uri = opts[:overlord_uri] || OVERLORD_URI
       @rollup_granularity = rollup_granularity_string(opts[:rollup_granularity])
       @strong_delete = opts[:strong_delete] || STRONG_DELETE
       @tuning_granularity = tuning_granularity_string(opts[:tuning_granularity])
       @tuning_window = opts[:tuning_window] || TUNING_WINDOW
+      @wait_time = opts[:wait_time] || WAIT_TIME
     end
 
     private

data/lib/druid/errors.rb

@@ -3,6 +3,7 @@ module Druid
   class ClientError < Error; end
   class ConnectionError < Error; end
   class QueryError < Error; end
+  class ValidationError < Error; end
 
   # Adopted from: https://github.com/lostisland/faraday/blob/master/lib/faraday/adapter/net_http.rb
   NET_HTTP_EXCEPTIONS = [

data/lib/druid/logger.rb

@@ -0,0 +1,82 @@
+# Supported Levels: https://github.com/twitter/util
+require 'logger'
+
+module Druid
+  class Logger
+    include Druid::TopLevelPackages
+
+    attr_accessor :logger
+    delegate :debug, :info, :warn, :error, :fatal, :unknown, to: :logger
+
+    def initialize
+      @logger = ::Logger.new(STDOUT)
+    end
+
+    def set_level(level)
+      set_logger_level(level)
+      set_logback_level(level)
+      set_twitter_level(level)
+    end
+
+    private
+
+    def set_logback_level(level)
+      org.slf4j.LoggerFactory.
+        getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME).
+        setLevel(get_logback_level(level))
+    end
+
+    def set_logger_level(level)
+      logger.level = get_logger_level(level)
+    end
+
+    def set_twitter_level(level)
+      com.twitter.logging.Logger.
+        get("com.twitter").
+        setLevel(java.util.logging.Level::WARNING)
+    end
+
+    def get_logback_level(level)
+      ch.qos.logback.classic.Level.const_get(map_logback_level(level))
+    end
+
+    def get_logger_level(level)
+      @logger.class.const_get(map_logger_level(level))
+    end
+
+    def get_twitter_level(level)
+      java.util.logging.Level.const_get(map_twitter_level(level))
+    end
+
+    def map_logback_level(level)
+      case level
+      when :critical
+        'ERROR'.freeze
+      when :fatal
+        'ERROR'.freeze
+      else
+        level.to_s.upcase
+      end
+    end
+
+    def map_logger_level(level)
+      case level
+      when :trace
+        'DEBUG'.freeze
+      when :critical
+        'ERROR'.freeze
+      else
+        level.to_s.upcase
+      end
+    end
+
+    def map_twitter_level(level)
+      case level
+      when :warn
+        'WARNING'.freeze
+      else
+        level.to_s.upcase
+      end
+    end
+  end
+end

data/lib/druid/logging.rb

@@ -1 +1,7 @@
-#TODO: Setup Logging and Do Something Useful
+module Druid
+  module Logging
+    def logger
+      @@logger ||= Druid::Logger.new
+    end
+  end
+end

data/lib/druid/queries/core.rb

@@ -0,0 +1,11 @@
+module Druid
+  module Queries
+    module Core
+      delegate :write_point, to: :writer
+
+      def query(opts)
+        Druid::Query.create(opts.merge(broker: broker))
+      end
+    end
+  end
+end

data/lib/druid/{query → queries}/datasource.rb

@@ -1,5 +1,5 @@
 module Druid
-  module Query
+  module Queries
     module Datasource
       java_import org.apache.zookeeper.ZKUtil
 

data/lib/druid/{query → queries}/task.rb

@@ -1,5 +1,5 @@
 module Druid
-  module Query
+  module Queries
     module Task
       delegate :shutdown_tasks, to: :overlord
     end

data/lib/druid/query.rb

@@ -0,0 +1,182 @@
+module Druid
+  class Query
+    attr_reader :aggregations,
+                :broker,
+                :dimensions,
+                :end_interval,
+                :fill_value,
+                :granularity,
+                :query_opts,
+                :query_type,
+                :range,
+                :result_key,
+                :start_interval
+
+    def initialize(opts)
+      @aggregations = opts[:aggregations].map{|agg| agg[:name]}
+      @broker = opts[:broker]
+      @dimensions = opts[:dimensions]
+      @fill_value = opts[:fill_value]
+      @granularity = opts[:granularity]
+      @range = parse_range(opts[:intervals])
+      @query_type = opts[:queryType]
+      @end_interval = calculate_end_interval
+      @start_interval = calculate_start_interval
+      @query_opts = opts_for_query(opts)
+    end
+
+    def execute
+      result = broker.query(query_opts)
+      fill_query_results(result)
+    end
+
+    private
+
+    # TODO: Can this be made smarter? Prefer to avoid case statements.
+    # Cases found here: http://druid.io/docs/latest/querying/granularities.html
+    def advance_interval(time)
+      case granularity
+      when 'second'
+        time.advance(seconds: 1)
+      when 'minute'
+        time.advance(minutes: 1)
+      when 'fifteen_minute'
+        time.advance(minutes: 15)
+      when 'thirty_minute'
+        time.advance(minutes: 30)
+      when 'hour'
+        time.advance(hours: 1)
+      when 'day'
+        time.advance(days: 1)
+      when 'week'
+        time.advance(weeks: 1)
+      when 'month'
+        time.advance(months: 1)
+      when 'quarter'
+        time.advance(months: 3)
+      when 'year'
+        time.advance(years: 1)
+      else
+        raise Druid::QueryError, 'Unsupported granularity'
+      end
+    end
+
+    def calculate_end_interval
+      iso8601_duration_end_interval(range)
+    end
+
+    def calculate_start_interval
+      time = iso8601_duration_start_interval(range)
+      start_of_interval(time)
+    end
+
+    def fill_empty_intervals(points, opts = {})
+      interval = start_interval
+      result = []
+
+      while interval <= end_interval do
+        # TODO:
+        # This will search the points every time, could be more performant if
+        # we track the 'current point' in the points and only compare the
+        # current point's timestamp
+        point = find_or_create_point(interval, points)
+        aggregations.each do |aggregation|
+          point[result_key][aggregation] = fill_value if point[result_key][aggregation].blank?
+          point[result_key].merge!(opts)
+        end
+        result << point
+        interval = advance_interval(interval)
+      end
+
+      result
+    end
+
+    # NOTE:
+    # This responsibility really lies in Druid, but until the feature works
+    # reliably in Druid, this is serves the purpose.
+    # https://github.com/druid-io/druid/issues/2106
+    def fill_query_results(query_result)
+      return query_result unless query_result.present? && fill_value.present?
+      parse_result_key(query_result.first)
+
+      #TODO: handle multi-dimensional group by
+      if group_by?
+        result = []
+        dimension_key = dimensions.first
+        groups = query_result.group_by{ |point| point[result_key][dimension_key] }
+        groups.each do |dimension_value, dimension_points|
+          result += fill_empty_intervals(dimension_points, { dimension_key => dimension_value })
+        end
+        result
+      else
+        fill_empty_intervals(query_result)
+      end
+    end
+
+    def find_or_create_point(interval, points)
+      point = points.find{ |point| point['timestamp'].to_s.to_time == interval.to_time }
+      point.present? ? point : { 'timestamp' => interval.iso8601(3), result_key => {} }
+    end
+
+    def group_by?
+      query_type == 'groupBy'
+    end
+
+    def iso8601_duration_start_interval(duration)
+      duration.split('/').first.to_time.utc
+    end
+
+    def iso8601_duration_end_interval(duration)
+      duration.split('/').last.to_time.utc
+    end
+
+    def opts_for_query(opts)
+      opts.except(:fill_value, :broker)
+    end
+
+    def parse_range(range)
+      range.is_a?(Array) ? range.first : range
+    end
+
+    def parse_result_key(point)
+      @result_key = point['event'].present? ? 'event' : 'result'
+    end
+
+    # TODO: Can this be made smarter? Prefer to avoid case statements.
+    # Cases found here: http://druid.io/docs/latest/querying/granularities.html
+    def start_of_interval(time)
+      case granularity
+      when 'second'
+        time.change(usec: 0)
+      when 'minute'
+        time.beginning_of_minute
+      when 'fifteen_minute'
+        first_fifteen = [45, 30, 15, 0].detect{ |m| m <= time.min }
+        time.change(min: first_fifteen)
+      when 'thirty_minute'
+        first_thirty = [30, 0].detect{ |m| m <= time.min }
+        time.change(min: first_thirty)
+      when 'hour'
+        time.beginning_of_hour
+      when 'day'
+        time.beginning_of_day
+      when 'week'
+        time.beginning_of_week
+      when 'month'
+        time.beginning_of_month
+      when 'quarter'
+        time.beginning_of_quarter
+      when 'year'
+        time.beginning_of_year
+      else
+        time
+      end
+    end
+
+    class << self
+      def create(opts)
+        new(opts).execute
+      end
+    end
+  end
+end

data/lib/druid/top_level_packages.rb

@@ -0,0 +1,11 @@
+module Druid
+  module TopLevelPackages
+    def ch
+      Java::Ch
+    end
+
+    def io
+      Java::Io
+    end
+  end
+end

data/lib/druid/version.rb

@@ -1,3 +1,3 @@
 module JrubyDruid
-  VERSION = '1.0.0-rc2'
+  VERSION = '1.0.0-rc3'
 end

data/lib/druid/writer/base.rb

@@ -17,7 +17,7 @@ module Druid
       def write_point(datasource, datapoint)
         datapoint = Druid::Writer::Tranquilizer::Datapoint.new(datapoint)
         sender = get_tranquilizer(datasource, datapoint)
-        sender.send(datapoint)
+        sender.safe_send(datapoint)
       end
 
       private

data/lib/druid/writer/tranquilizer.rb

@@ -1,48 +1,16 @@
 module Druid
   module Writer
     module Tranquilizer
-      class << self
-        def ch
-          Java::Ch
-        end
+      extend Druid::TopLevelPackages
 
-        def io
-          Java::Io
-        end
-      end
-      
       java_import com.google.common.collect.ImmutableList
       java_import com.google.common.collect.ImmutableMap
-      java_import ch.qos.logback.classic.Level
-      java_import ch.qos.logback.classic.encoder.PatternLayoutEncoder
-      java_import ch.qos.logback.core.FileAppender
       java_import com.metamx.tranquility.beam.ClusteredBeamTuning
       java_import io.druid.query.aggregation.LongSumAggregatorFactory
       java_import io.druid.granularity.QueryGranularity
       java_import io.druid.data.input.impl.TimestampSpec
       java_import org.apache.curator.framework.CuratorFrameworkFactory
-      java_import org.slf4j.LoggerFactory
-      java_import org.slf4j.Logger
       java_import Java::ScalaCollection::JavaConverters
-
-      logger = Druid::Writer::Tranquilizer::LoggerFactory.getLogger(Druid::Writer::Tranquilizer::Logger.ROOT_LOGGER_NAME)
-      logger.detachAndStopAllAppenders
-
-      appender = Druid::Writer::Tranquilizer::FileAppender.new
-      context = logger.getLoggerContext
-      encoder = Druid::Writer::Tranquilizer::PatternLayoutEncoder.new
-
-      encoder.setPattern("%date %level [%thread] %logger{10} [%file:%line] %msg%n")
-      encoder.setContext(context)
-      encoder.start
-
-      appender.setFile('jruby-druid.log')
-      appender.setEncoder(encoder)
-      appender.setContext(context)
-      appender.start
-
-      logger.addAppender(appender)
-      logger.setLevel(Druid::Writer::Tranquilizer::Level::TRACE)
     end
   end
 end

data/lib/druid/writer/tranquilizer/base.rb

@@ -5,7 +5,12 @@ module Druid
   module Writer
     module Tranquilizer
       class Base
-        attr_reader :config, :curator, :datasource, :rollup, :service, :tuning
+        attr_reader :config,
+                    :curator,
+                    :datasource,
+                    :rollup,
+                    :service,
+                    :tuning
 
         def initialize(params)
           @config = params[:config]
@@ -18,8 +23,11 @@ module Druid
           start
         end
 
-        def send(datapoint)
-          service.send(argument_map(datapoint)).addEventListener(EventListener.new)
+        def safe_send(datapoint)
+          thread = Thread.new{ send(datapoint) }
+          result = thread.join(@config.wait_time)
+          raise Druid::ConnectionError, 'Error connecting to ZooKeeper' unless result
+          Druid::Writer::Tranquilizer::Future.new(result.value)
         end
 
         def start
@@ -58,6 +66,10 @@ module Druid
           builder = builder.druidBeamConfig(DruidBeamConfig.build(true)) if config.strong_delete
           builder.buildTranquilizer
         end
+
+        def send(datapoint)
+          service.send(argument_map(datapoint)).addEventListener(EventListener.new)
+        end
       end
     end
   end

data/lib/druid/writer/tranquilizer/datapoint.rb

@@ -8,8 +8,8 @@ module Druid
 
         def initialize(datapoint)
           @timestamp = build_time(datapoint[:timestamp])
-          @dimensions = datapoint[:dimensions].with_indifferent_access
-          @metrics = datapoint[:metrics].with_indifferent_access
+          @dimensions = parse_dimensions(datapoint[:dimensions])
+          @metrics = parse_metrics(datapoint[:metrics])
         end
 
         private
@@ -18,6 +18,15 @@ module Druid
           time = Time.now.utc unless time
           Hash[TIMESTAMP_LABEL, time.iso8601]
         end
+
+        def parse_dimensions(dimensions)
+          dimensions.present? ? dimensions.with_indifferent_access : {}
+        end
+
+        def parse_metrics(metrics)
+          raise ValidationError, 'Must specify at least one metric' unless metrics.present?
+          metrics.with_indifferent_access
+        end
       end
     end
   end

data/lib/druid/writer/tranquilizer/event_listener.rb

@@ -2,14 +2,15 @@ module Druid
   module Writer
     module Tranquilizer
       class EventListener
+        include Logging
         include_package com.twitter.util.FutureEventListener
 
         def onSuccess(data)
-          # puts "success: #{data.to_s}" #TODO: Log this (trace)
+          # logger.debug data.to_s
         end
 
         def onFailure(error)
-          puts "failure: #{error.to_s}" #TODO: Log this (debug)
+          logger.warn error.to_s
         end
       end
     end

data/lib/druid/writer/tranquilizer/future.rb

@@ -0,0 +1,39 @@
+module Druid
+  module Writer
+    module Tranquilizer
+      class Future
+        AWAIT = com.twitter.util.Awaitable::CanAwait
+        WAIT_TIME = 20
+
+        attr_reader :future
+        delegate :isDefined, to: :future
+
+        def initialize(future)
+          @future = future
+        end
+
+        def failure?(wait_time  = WAIT_TIME)
+          begin
+            future.ready(build_duration(wait_time), AWAIT).isThrow
+          rescue Java::ComTwitterUtil::TimeoutException => e
+            raise Druid::ConnectionError, 'Future timed out.'
+          end
+        end
+
+        def success?(wait_time = WAIT_TIME)
+          begin
+            future.ready(build_duration(wait_time), AWAIT).isReturn
+          rescue Java::ComTwitterUtil::TimeoutException => e
+            raise Druid::ConnectionError, 'Future timed out.'
+          end
+        end
+
+        private
+
+        def build_duration(duration)
+          com.twitter.util.Duration.fromSeconds(duration)
+        end
+      end
+    end
+  end
+end

data/lib/jruby-druid.rb

@@ -4,18 +4,22 @@ Dir["#{File.dirname(__FILE__)}/../vendor/tranquility/*.jar"].each { |file| requi
 require "active_support/all"
 require "json"
 
+require "druid/top_level_packages"
 require "druid/configuration"
 require "druid/connection"
 require "druid/errors"
+require "druid/logger"
+require "druid/logging"
+require "druid/query"
 require "druid/version"
 
 require "druid/node/broker"
 require "druid/node/coordinator"
 require "druid/node/overlord"
 
-require "druid/query/core"
-require "druid/query/datasource"
-require "druid/query/task"
+require "druid/queries/core"
+require "druid/queries/datasource"
+require "druid/queries/task"
 
 require "druid/writer/base"
 
@@ -28,6 +32,7 @@ require "druid/writer/tranquilizer/dimensions"
 require "druid/writer/tranquilizer/druid_beams"
 require "druid/writer/tranquilizer/druid_beam_config"
 require "druid/writer/tranquilizer/event_listener"
+require "druid/writer/tranquilizer/future"
 require "druid/writer/tranquilizer/rollup"
 require "druid/writer/tranquilizer/timestamper"
 require "druid/writer/tranquilizer/tuning"

metadata

@@ -1,49 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: jruby-druid
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.rc2
+  version: 1.0.0.pre.rc3
 platform: ruby
 authors:
 - Andre LeBlanc
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2016-07-14 00:00:00.000000000 Z
+date: 2016-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
   name: activesupport
   prerelease: false
   type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '4.0'
-- !ruby/object:Gem::Dependency
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.9'
-  name: zk
-  prerelease: false
-  type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '0'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.11'
+        version: '1.7'
   name: bundler
   prerelease: false
   type: :development
@@ -51,7 +37,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.11'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -146,13 +132,16 @@ files:
 - lib/druid/configuration.rb
 - lib/druid/connection.rb
 - lib/druid/errors.rb
+- lib/druid/logger.rb
 - lib/druid/logging.rb
 - lib/druid/node/broker.rb
 - lib/druid/node/coordinator.rb
 - lib/druid/node/overlord.rb
-- lib/druid/query/core.rb
-- lib/druid/query/datasource.rb
-- lib/druid/query/task.rb
+- lib/druid/queries/core.rb
+- lib/druid/queries/datasource.rb
+- lib/druid/queries/task.rb
+- lib/druid/query.rb
+- lib/druid/top_level_packages.rb
 - lib/druid/version.rb
 - lib/druid/writer/base.rb
 - lib/druid/writer/tranquilizer.rb
@@ -164,6 +153,7 @@ files:
 - lib/druid/writer/tranquilizer/druid_beam_config.rb
 - lib/druid/writer/tranquilizer/druid_beams.rb
 - lib/druid/writer/tranquilizer/event_listener.rb
+- lib/druid/writer/tranquilizer/future.rb
 - lib/druid/writer/tranquilizer/rollup.rb
 - lib/druid/writer/tranquilizer/timestamper.rb
 - lib/druid/writer/tranquilizer/tuning.rb

data/lib/druid/query/core.rb

@@ -1,8 +0,0 @@
-module Druid
-  module Query
-    module Core
-      delegate :query, to: :broker
-      delegate :write_point, to: :writer
-    end
-  end
-end