olaf 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d45d092623bf97e4a23624cfcc145afd281dcb91011bee43e9086e35f1af9ff
-  data.tar.gz: 54ae40103a4ed018b04be956f86ad9316a2239ab719e721e33eb9d79a11e1b2c
+  metadata.gz: dd476121e33e97e071c41dc3e75a8128eddee118c93f0ec93acd61fa167b0523
+  data.tar.gz: 843da2abba59ade1dc644b47a4575abf77102ed7a58dd0ce1c45e6f7ba6f7968
 SHA512:
-  metadata.gz: f874ca55bef0c740c90084a7db2e0487668a55c4af33e6d8879c798677aa4921eb0aa1c1f146d0af54c2de854b61c783c0a70e362b31c2cc5baf8cbee8ab37d4
-  data.tar.gz: 97331d8aa92d9b735b45c7931a08bccc49db2e97caee1ab11c1b0f19c067b63192a29625c356a90d5d85eee8f1f59ed924c4712d71ba5bbfbe581a058a911cc2
+  metadata.gz: 577d617e9e02f3bbaa858425e70e6d87803af2a9d2764626d30e6d0fda0bce130171b33566e642354e30990ffe19d7e9b4b8c55f48f29d63712a1e81743eb31c
+  data.tar.gz: 39da006e922a15ad3fa88a7c7c45979aff8eeb8e13b6e4c5340ee52608f54cf4930b4314e4925c2103ed7559604f664fbb18f2dd8084903605075e1d9f908293

data/README.md

@@ -88,7 +88,8 @@ Olaf.instance.register_result(FetchUsers, [{ id: 42 }], with: { department_id: 1
 ```
 
 Whichever driver runs the query, a failure it reports is wrapped into
-`Olaf::QueryExecutionError`, carrying the query metadata.
+`Olaf::QueryExecutionError`, carrying the query metadata. A BigQuery connection
+that keeps dropping can be the exception: see below.
 
 ## BigQuery
 
@@ -97,7 +98,8 @@ Olaf::BigQuery.new(
   project: 'carwow',
   credentials: JSON.parse(ENV['BIGQUERY_CREDENTIALS']),  # ambient Google credentials when omitted
   maximum_bytes_billed: 5 * Olaf::BigQuery::GIGABYTE,    # default: 1 GiB
-  labels: { service: 'flatmin', country: 'uk' }
+  labels: { service: 'flatmin', country: 'uk' },
+  retry_delays: [1, 2]                                   # default: retry twice, after 1s then 2s
 )
 ```
 
@@ -114,6 +116,17 @@ The query runs as a job, so that it can be capped and labelled:
   ```ruby
   driver :big_query, maximum_bytes_billed: 10 * Olaf::BigQuery::GIGABYTE
   ```
+* A call whose connection drops mid-request is retried once after each of the
+  `retry_delays`. Waiting for the job is retried on its own, so a dropped status
+  check doesn't start a second job. A drop arrives in one of two forms, and both
+  are retried:
+  * A bare `OpenSSL::SSL::SSLError`, which is how google-apis-core 0.x reports
+    an SSL read that ends early. Once the retries run out it is raised as it is,
+    not wrapped, so a job runner such as Sidekiq can retry it in turn.
+  * A `Google::Cloud::Error` caused by a `Google::Apis::TransmissionError`.
+    google-apis-core 1.x reports every dropped connection this way, and 0.x
+    does the same for a reset connection. Once the retries run out it is wrapped
+    into `Olaf::QueryExecutionError`, like any other error the API reports.
 
 `Olaf.execute` returns the rows. `Olaf.instance(:big_query).run(query)` returns
 the finished job instead, for its statistics:

data/lib/olaf/drivers/big_query.rb

@@ -1,5 +1,6 @@
 # Not a dependency of the gem: consumers of this driver add it themselves.
 require 'google/cloud/bigquery'
+require 'securerandom'
 
 # The API client debug-logs whole response bodies, which for a warehouse query
 # is the entire result set.
@@ -17,14 +18,17 @@ module Olaf
     LABEL_FORMAT = /[^a-z0-9_-]/.freeze
     LABEL_MAX_LENGTH = 63
 
+    RETRY_DELAYS = [1, 2].freeze
+
     # Credentials default to the ambient Google ones, and the client is built
     # from the arguments unless one is given.
     def initialize(project: nil, credentials: nil, maximum_bytes_billed: DEFAULT_MAXIMUM_BYTES_BILLED,
-                   labels: {}, client: nil)
+                   labels: {}, retry_delays: RETRY_DELAYS, client: nil)
       @project = project
       @credentials = credentials
       @maximum_bytes_billed = maximum_bytes_billed
       @labels = labels
+      @retry_delays = retry_delays
       @client = client
     end
 
@@ -35,15 +39,11 @@ module Olaf
     # Returns the finished job, so callers can read its stats (bytes billed,
     # cache hit) on top of its rows.
     #
-    #   @raises Olaf::QueryExecutionError
+    #   @raises Olaf::QueryExecutionError, or the OpenSSL::SSL::SSLError of a
+    #   connection that keeps dropping, which google-apis-core 0.x doesn't wrap
     def run(olaf_query)
-      job = client.query_job(
-        sql(olaf_query),
-        params: params(olaf_query),
-        maximum_bytes_billed: maximum_bytes_billed(olaf_query),
-        labels: labels(olaf_query)
-      )
-      job.wait_until_done!
+      job = start_job(olaf_query)
+      retrying_dropped_connections { job.wait_until_done! }
 
       raise QueryExecutionError.new(job.error.to_h['message'].to_s, olaf_query) if job.failed?
 
@@ -58,9 +58,51 @@ module Olaf
       @client ||= Google::Cloud::Bigquery.new(project: @project, credentials: @credentials)
     end
 
+    # A connection can drop after BigQuery has started the job, so every attempt
+    # reuses one job ID: BigQuery refuses the retry as a duplicate, and the job
+    # already started is loaded rather than running and billing the query twice.
+    # If the lookup can't find the job, as happens for one in a single region,
+    # the refusal is re-raised.
+    def start_job(olaf_query)
+      job_id = "job_#{SecureRandom.urlsafe_base64(21)}"
+
+      retrying_dropped_connections do
+        client.query_job(
+          sql(olaf_query),
+          params: params(olaf_query),
+          maximum_bytes_billed: maximum_bytes_billed(olaf_query),
+          labels: labels(olaf_query),
+          job_id:
+        )
+      rescue Google::Cloud::AlreadyExistsError
+        client.job(job_id) || raise
+      end
+    end
+
+    # google-cloud-bigquery switches off google-apis-core's retries.
+    def retrying_dropped_connections
+      @retry_delays.each do |delay|
+        return yield
+      rescue StandardError => error
+        raise unless dropped_connection?(error)
+
+        sleep delay
+      end
+
+      yield
+    end
+
+    # google-apis-core 1.x reports every dropped connection as a TransmissionError,
+    # and 0.x does the same for a reset connection; google-cloud-bigquery wraps it.
+    def dropped_connection?(error)
+      error.is_a?(OpenSSL::SSL::SSLError) ||
+        (error.is_a?(Google::Cloud::Error) && error.cause.is_a?(Google::Apis::TransmissionError))
+    end
+
     # Google::Cloud::Error covers everything the API reports, Google::Auth::Error
     # credentials missing or expired before a call is made. The second one only
-    # exists in googleauth 1.14 and later.
+    # exists in googleauth 1.14 and later. A bare OpenSSL::SSL::SSLError is left
+    # out, so once its retries run out the caller's job runner can still retry it.
     def wrapped_errors
       @wrapped_errors ||= [
         Google::Cloud::Error,

data/olaf.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'olaf'
-  s.version     = '1.0.0'
+  s.version     = '1.0.1'
   s.date        = Time.now.strftime('%Y-%m-%d')
   s.summary     = 'Ruby wrapper for warehouse queries.'
   s.authors     = ['Emiliano Mancuso']

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: olaf
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Emiliano Mancuso
 bindir: bin
 cert_chain: []
-date: 2026-10-09 00:00:00.000000000 Z
+date: 2026-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-cloud-bigquery
@@ -75,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.20
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby wrapper for warehouse queries.
 test_files: