presto-client 0.5.12 → 0.5.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 080d9921005db52eff8e73d34436dd26a3b034bd
-  data.tar.gz: 431dd1f2a7a1f3f199fd5fca9d80ba7a8135517b
+  metadata.gz: 25d825cdb3befbfa69b368f05d2267ed4bc3affd
+  data.tar.gz: abbc72ac27018abef03fbe2c5a122cc96aff68e1
 SHA512:
-  metadata.gz: a509d1c1c269011e695d1bbda97f32b7f85203accfcc1986889059ac9130836704a2c26e21e86ab6381089a9fc6568752f22f62186560ce47920b4db2a536224
-  data.tar.gz: 254363164f1df8e403c35b7bb17f17cdc63719b09a65495180accf5f493339742cc9a54ea662470b523096ae015b3ade3109d68cceff05c014682085dc8e1580
+  metadata.gz: f5988faa2e414bdb31a1368eb3a829e1a30872195a8bf6aa1a0ece60edb832ca64af70f6e3cfa8b2e85e7b20786b2ab943fdfa8b340158fab33d5d8279b8a440
+  data.tar.gz: 00eb3921405da85361bda22d588982e3e8d706ac118bd694cfab94849812bdb25e27ce8e5c0ba43d437d21a1fdbf03d9a09075722e4569082680ce5fa376c25e

data/ChangeLog

@@ -1,3 +1,9 @@
+2018-12-10 version 0.5.13
+
+* Added `query_timeout` and `plan_timeout` options with default disabled
+* Changed timer to use CLOCK_MONOTONIC to avoid unexpected behavior when
+  system clock is updated
+
 2018-08-07 version 0.5.12
 
 * Upgrade to Presto 0.205 model

data/README.md

@@ -94,12 +94,14 @@ $ bundle exec rake modelgen:latest
 * **time_zone** sets time zone of queries. Time zone affects some functions such as `format_datetime`.
 * **language** sets language of queries. Language affects some functions such as `format_datetime`.
 * **properties** set session properties. Session properties affect internal behavior such as `hive.force_local_scheduling: true`, `raptor.reader_stream_buffer_size: "32MB"`, etc.
+* **query_timeout** sets timeout in seconds for the entire query execution (from the first API call until there're no more output data). If timeout happens, client raises PrestoQueryTimeoutError. Default is nil (disabled).
+* **plan_timeout** sets timeout in seconds for query planning execution (from the first API call until result columns become available). If timeout happens, client raises PrestoQueryTimeoutError. Default is nil (disabled).
 * **http_headers** sets custom HTTP headers. It must be a Hash of string to string.
 * **http_proxy** sets host:port of a HTTP proxy server.
 * **http_debug** enables debug message to STDOUT for each HTTP requests.
 * **http_open_timeout** sets timeout in seconds to open new HTTP connection.
 * **http_timeout** sets timeout in seconds to read data from a server.
-* **model_version** set the presto version to which a job is submitted. Supported versions are 0.153 and 0.149. Default is 0.153.
+* **model_version** set the presto version to which a job is submitted. Supported versions are 0.205, 0.178, 0.173, 0.153 and 0.149. Default is 0.205.
 
 See [RDoc](http://www.rubydoc.info/gems/presto-client/) for the full documentation.
 
@@ -112,4 +114,3 @@ See [RDoc](http://www.rubydoc.info/gems/presto-client/) for the full documentati
 3. git commit -am "vX.Y.Z"
 4. git tag "vX.Y.Z"
 5. git push --tags
-

data/lib/presto/client/errors.rb

@@ -40,4 +40,7 @@ module Presto::Client
 
     attr_reader :error_code, :error_name, :failure_info
   end
+
+  class PrestoQueryTimeoutError < PrestoError
+  end
 end

data/lib/presto/client/statement_client.rb

@@ -40,6 +40,15 @@ module Presto::Client
         @models = Models
       end
 
+      @plan_timeout = options[:plan_timeout]
+      @query_timeout = options[:query_timeout]
+
+      if @plan_timeout || @query_timeout
+        # this is set before the first call of faraday_get_with_retry so that
+        # resuming StatementClient with next_uri is also under timeout control.
+        @started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
       if next_uri
         response = faraday_get_with_retry(next_uri)
         @results = @models::QueryResults.decode(parse_body(response))
@@ -110,11 +119,13 @@ module Presto::Client
       if closed? || !has_next?
         return false
       end
-      uri = @results.next_uri
 
+      uri = @results.next_uri
       response = faraday_get_with_retry(uri)
       @results = decode_model(uri, parse_body(response), @models::QueryResults)
 
+      raise_if_timeout!
+
       return true
     end
 
@@ -156,7 +167,7 @@ module Presto::Client
     private :parse_body
 
     def faraday_get_with_retry(uri, &block)
-      start = Time.now
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       attempts = 0
 
       begin
@@ -182,14 +193,46 @@ module Presto::Client
           end
         end
 
+        raise_if_timeout!
+
         attempts += 1
         sleep attempts * 0.1
-      end while (Time.now - start) < @retry_timeout && !@closed
+      end while (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) < @retry_timeout && !@closed
 
       @exception = PrestoHttpError.new(408, "Presto API error due to timeout")
       raise @exception
     end
 
+    def raise_if_timeout!
+      if @started_at
+        if @results && @results.next_uri == nil
+          # query is already done
+          return
+        end
+
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started_at
+
+        if @query_timeout && elapsed > @query_timeout
+          raise_timeout_error!
+        end
+
+        if @plan_timeout && (@results == nil || @results.columns == nil) &&
+            elapsed > @plan_timeout
+          # @results is not set (even first faraday_get_with_retry isn't called yet) or
+          # result from Presto doesn't include result schema. Query planning isn't done yet.
+          raise_timeout_error!
+        end
+      end
+    end
+
+    def raise_timeout_error!
+      if query_id = @results && @results.id
+        raise PrestoQueryTimeoutError, "Query #{query_id} timed out"
+      else
+        raise PrestoQueryTimeoutError, "Query timed out"
+      end
+    end
+
     def cancel_leaf_stage
       if uri = @results.next_uri
         response = @faraday.delete do |req|

data/lib/presto/client/version.rb

@@ -15,6 +15,6 @@
 #
 module Presto
   module Client
-    VERSION = "0.5.12"
+    VERSION = "0.5.13"
   end
 end

data/spec/statement_client_spec.rb

@@ -401,5 +401,160 @@ describe Presto::Client::StatementClient do
 
     StatementClient.new(faraday, query, options)
   end
+
+  describe "query timeout" do
+    let :headers do
+      {
+        "User-Agent" => "presto-ruby/#{VERSION}",
+        "X-Presto-Catalog" => options[:catalog],
+        "X-Presto-Schema" => options[:schema],
+        "X-Presto-User" => options[:user],
+        "X-Presto-Language" => options[:language],
+        "X-Presto-Time-Zone" => options[:time_zone],
+      }
+    end
+
+    let :planning_response do
+      {
+        id: "queryid",
+        nextUri: 'http://localhost/v1/next_uri',
+        stats: {},
+      }
+    end
+
+    let :early_running_response do
+      {
+        id: "queryid",
+        nextUri: 'http://localhost/v1/next_uri',
+        stats: {},
+        columns: [{name: "_col0", type: "bigint"}],
+      }
+    end
+
+    let :late_running_response do
+      {
+        id: "queryid",
+        nextUri: 'http://localhost/v1/next_uri',
+        stats: {},
+        columns: [{name: "_col0", type: "bigint"}],
+        data: "",
+      }
+    end
+
+    let :done_response do
+      {
+        id: "queryid",
+        stats: {},
+        columns: [{name: "_col0", type: "bigint"}],
+      }
+    end
+
+    before(:each) do
+    end
+
+    [:plan_timeout, :query_timeout].each do |timeout_type|
+      it "raises PrestoQueryTimeoutError if timeout during planning" do
+        stub_request(:post, "localhost/v1/statement").
+          with(body: query, headers: headers).
+          to_return(body: planning_response.to_json)
+
+        client = StatementClient.new(faraday, query, options.merge(timeout_type => 1))
+
+        stub_request(:get, "localhost/v1/next_uri").
+          with(headers: headers).
+          to_return(body: planning_response.to_json)
+        client.advance
+
+        sleep 1
+        stub_request(:get, "localhost/v1/next_uri").
+          with(headers: headers).
+          to_return(body: planning_response.to_json)
+        lambda do
+          client.advance
+        end.should raise_error(Presto::Client::PrestoQueryTimeoutError, "Query queryid timed out")
+      end
+
+      it "raises PrestoQueryTimeoutError if timeout during initial resuming" do
+        stub_request(:get, "localhost/v1/next_uri").
+          with(headers: headers).
+          to_return(body: lambda{|req| raise Timeout::Error.new("execution expired")})
+
+        lambda do
+          StatementClient.new(faraday, query, options.merge(timeout_type => 1), "/v1/next_uri")
+        end.should raise_error(Presto::Client::PrestoQueryTimeoutError, "Query timed out")
+      end
+
+      it "raises PrestoHttpError if timeout during initial resuming and #{timeout_type} < retry_timeout" do
+        stub_request(:get, "localhost/v1/next_uri").
+          with(headers: headers).
+          to_return(body: lambda{|req| raise Timeout::Error.new("execution expired")})
+
+        lambda do
+          StatementClient.new(faraday, query, options.merge(timeout_type => 2, retry_timeout: 1), "/v1/next_uri")
+        end.should raise_error(Presto::Client::PrestoHttpError, "Presto API error due to timeout")
+      end
+    end
+
+    it "doesn't raise errors with plan_timeout if query planning is done" do
+      stub_request(:post, "localhost/v1/statement").
+        with(body: query, headers: headers).
+        to_return(body: planning_response.to_json)
+
+      client = StatementClient.new(faraday, query, options.merge(plan_timeout: 1))
+
+      sleep 1
+
+      stub_request(:get, "localhost/v1/next_uri").
+        with(headers: headers).
+        to_return(body: early_running_response.to_json)
+      client.advance
+
+      stub_request(:get, "localhost/v1/next_uri").
+        with(headers: headers).
+        to_return(body: late_running_response.to_json)
+      client.advance
+    end
+
+    it "raises PrestoQueryTimeoutError if timeout during execution" do
+      stub_request(:post, "localhost/v1/statement").
+        with(body: query, headers: headers).
+        to_return(body: planning_response.to_json)
+
+      client = StatementClient.new(faraday, query, options.merge(query_timeout: 1))
+
+      stub_request(:get, "localhost/v1/next_uri").
+        with(headers: headers).
+        to_return(body: early_running_response.to_json)
+      client.advance
+
+      sleep 1
+      stub_request(:get, "localhost/v1/next_uri").
+        with(headers: headers).
+        to_return(body: late_running_response.to_json)
+      lambda do
+        client.advance
+      end.should raise_error(Presto::Client::PrestoQueryTimeoutError, "Query queryid timed out")
+    end
+
+    it "doesn't raise errors if query is done" do
+      stub_request(:post, "localhost/v1/statement").
+        with(body: query, headers: headers).
+        to_return(body: planning_response.to_json)
+
+      client = StatementClient.new(faraday, query, options.merge(query_timeout: 1))
+
+      stub_request(:get, "localhost/v1/next_uri").
+        with(headers: headers).
+        to_return(body: early_running_response.to_json)
+      client.advance
+
+      sleep 1
+      stub_request(:get, "localhost/v1/next_uri").
+        with(headers: headers).
+        to_return(body: done_response.to_json)
+      client.advance
+    end
+
+  end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: presto-client
 version: !ruby/object:Gem::Version
-  version: 0.5.12
+  version: 0.5.13
 platform: ruby
 authors:
 - Sadayuki Furuhashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-07 00:00:00.000000000 Z
+date: 2018-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -170,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Presto client library