olaf 0.3.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d1640a5221b0ed5a71b4fbb2ca11d113d69ef7436e7b7c2628497c4767a4245
-  data.tar.gz: fd816660fe86290c5f5d8148a11823b2c2580e66096817d343b958fcbb1fc30e
+  metadata.gz: dd476121e33e97e071c41dc3e75a8128eddee118c93f0ec93acd61fa167b0523
+  data.tar.gz: 843da2abba59ade1dc644b47a4575abf77102ed7a58dd0ce1c45e6f7ba6f7968
 SHA512:
-  metadata.gz: b1f71e253ff7cb95a7eef3d97324f6615d43c57aaa39e9128fcdce5f8ef683ed2a742d852aff034adf3cbd8fd04ddfa2d58a1c7372edea79843f0ab12581735a
-  data.tar.gz: db997081fd2f622d354cd7bcb65a73c45ef55eba1bb71d8788b08590cb02e3500cdc428da78697ff838666daac3996d6f8a83cdfd14bbd3750655e308967507c
+  metadata.gz: 577d617e9e02f3bbaa858425e70e6d87803af2a9d2764626d30e6d0fda0bce130171b33566e642354e30990ffe19d7e9b4b8c55f48f29d63712a1e81743eb31c
+  data.tar.gz: 39da006e922a15ad3fa88a7c7c45979aff8eeb8e13b6e4c5340ee52608f54cf4930b4314e4925c2103ed7559604f664fbb18f2dd8084903605075e1d9f908293

data/README.md

@@ -1,7 +1,6 @@
 # Olaf
 
-Olaf is a small Ruby wrapper for warehouse queries, running them in Snowflake or
-in BigQuery.
+Olaf is a small Ruby wrapper for warehouse queries, running them in BigQuery.
 
 ![Olaf](https://user-images.githubusercontent.com/56375/96335285-8c86f080-106f-11eb-9489-999a884f1246.jpg)
 
@@ -13,7 +12,6 @@ and only when it is used, so add to your `Gemfile` the ones you configure:
 
 | Driver            | Gems                    | Also needs              |
 | ----------------- | ----------------------- | ----------------------- |
-| `Olaf::Snowflake` | `sequel`, `ruby-odbc`   | the ODBC system library |
 | `Olaf::BigQuery`  | `google-cloud-bigquery` |                         |
 | `Olaf::Fake`      | —                       |                         |
 
@@ -34,7 +32,7 @@ control in the code and in tests.
 class FetchUsers
   include Olaf::QueryDefinition
 
-  template './snowflake/users_in_department.sql'
+  template './big_query/users_in_department.sql'
 
   argument :department_id
 
@@ -52,7 +50,6 @@ Olaf.execute(query)
 One driver, which every query runs on:
 
 ```ruby
-Olaf.configure(user: 'olaf')             # Olaf::Snowflake, the default
 Olaf.configure(olaf_driver: Olaf::Fake)  # ideal for testing
 ```
 
@@ -62,10 +59,10 @@ run on the `default:`, the first one given when it is not specified:
 ```ruby
 Olaf.configure(
   drivers: {
-    snowflake: Olaf::Snowflake.new(user: 'olaf'),
-    big_query: Olaf::BigQuery.new(project: 'carwow', labels: { service: 'flatmin' })
+    big_query: Olaf::BigQuery.new(project: 'carwow', labels: { service: 'flatmin' }),
+    fake: Olaf::Fake.new
   },
-  default: :snowflake
+  default: :big_query
 )
 
 class FetchUsers
@@ -91,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
 
@@ -100,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
 )
 ```
 
@@ -117,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/lib/olaf/query_definition/class_methods.rb

@@ -3,7 +3,7 @@ module Olaf
     module ClassMethods
       # Creates a new instance of the Query defined and validates
       # the parameters passed, leaving the instance in a ready-to-execute state.
-      #   @return Snowflake::QueryDefinition instance
+      #   @return Olaf::QueryDefinition instance
       def prepare(**vars)
         new(**vars).prepare
       end
@@ -15,9 +15,9 @@ module Olaf
       end
 
       # Define an argument for the query matching a placeholder in the template.
-      # The Sequel gem, will fill the placeholders in the SQL query escaping the
-      # value passed as an argument. Sometimes, we need to pass an argument as
-      # literal to avoid the single quotes added by Sequel (i.e. sending a table_name)
+      # The driver binds the value passed as a query parameter. Sometimes, we need
+      # to pass an argument as literal to substitute it into the SQL instead
+      # (i.e. sending a table_name)
       #
       # options - Hash config for each argument
       #   :as - Argument Type
@@ -26,7 +26,7 @@ module Olaf
       # Example:
       #
       #     class OneQuery
-      #       include Snowflake::QueryDefinition
+      #       include Olaf::QueryDefinition
       #
       #       template 'reports/one.sql'
       #
@@ -48,7 +48,7 @@ module Olaf
       # Example:
       #
       #     class OneQuery
-      #       include Snowflake::QueryDefinition
+      #       include Olaf::QueryDefinition
       #
       #       template 'reports/one.sql'
       #     end
@@ -93,7 +93,7 @@ module Olaf
       # Example:
       #
       #     class OneQuery
-      #       include Snowflake::QueryDefinition
+      #       include Olaf::QueryDefinition
       #
       #       row_object MyOwnObject
       #     end

data/lib/olaf/query_definition.rb

@@ -20,8 +20,8 @@ module Olaf
     #
     #   @return QueryDefinition instance
     #
-    #   @raises Snowflake::UndefinedArgumentsError
-    #   @raises Snowflake::MissingArgumentsError
+    #   @raises Olaf::UndefinedArgumentsError
+    #   @raises Olaf::MissingArgumentsError
     def prepare
       @sql_template ||= File.read(self.class.template)
 

data/lib/olaf.rb

@@ -5,21 +5,19 @@ module Olaf
   # Autoloaded: each driver pulls in its own client library.
   autoload :BigQuery, File.expand_path('olaf/drivers/big_query', __dir__)
   autoload :Fake, File.expand_path('olaf/drivers/fake', __dir__)
-  autoload :Snowflake, File.expand_path('olaf/drivers/snowflake', __dir__)
 
   DEFAULT_DRIVER = :default
 
   # Configures the drivers used to execute queries, either a single one built
   # from the arguments given:
   #
-  #     Olaf.configure(user: 'olaf')             # Olaf::Snowflake, the default
   #     Olaf.configure(olaf_driver: Olaf::Fake)  # ideal for testing
   #
   # or several instantiated ones, which queries pick by name with `driver`:
   #
   #     Olaf.configure(
-  #       drivers: { snowflake: Olaf::Snowflake.new(user: 'olaf'), big_query: Olaf::BigQuery.new(project: 'carwow') },
-  #       default: :snowflake
+  #       drivers: { big_query: Olaf::BigQuery.new(project: 'carwow'), fake: Olaf::Fake.new },
+  #       default: :big_query
   #     )
   #
   #   @return the default Olaf driver instance
@@ -36,7 +34,9 @@ module Olaf
 
         [drivers.dup, default_driver]
       else
-        [{ DEFAULT_DRIVER => (olaf_driver || Snowflake).new(**args) }, DEFAULT_DRIVER]
+        raise ArgumentError, 'Pass `drivers:` or a single `olaf_driver:` to configure' unless olaf_driver
+
+        [{ DEFAULT_DRIVER => olaf_driver.new(**args) }, DEFAULT_DRIVER]
       end
 
     instance
@@ -64,9 +64,8 @@ module Olaf
   # what keeps `Olaf::Fake` covering every query in tests.
   #
   #   @return Olaf driver instance
-  #     * Olaf::Fake      - Ideal for testing
-  #     * Olaf::Snowflake - Sequel.odbc driver to run queries in Snowflake
-  #     * Olaf::BigQuery  - google-cloud-bigquery driver to run queries in BigQuery
+  #     * Olaf::Fake     - Ideal for testing
+  #     * Olaf::BigQuery - google-cloud-bigquery driver to run queries in BigQuery
   #
   def self.instance(name = nil)
     drivers = @drivers || raise('You need to configure Olaf before using it!')

data/olaf.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'olaf'
-  s.version     = '0.3.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']
@@ -18,9 +18,7 @@ Gem::Specification.new do |s|
 
   # Drivers load their own client libraries, so consumers only install the ones
   # they configure:
-  #   Olaf::Snowflake - sequel and ruby-odbc
-  #   Olaf::BigQuery  - google-cloud-bigquery
+  #   Olaf::BigQuery - google-cloud-bigquery
   s.add_development_dependency 'google-cloud-bigquery', '~> 1.64'
-  s.add_development_dependency 'sequel', '~> 5.37'
   s.add_development_dependency 'test-unit', '~> 3.3'
 end

data/test/olaf_configure_test.rb

@@ -20,10 +20,10 @@ class OlafConfigureTest < Test::Unit::TestCase
     assert_equal Olaf.instance.config, { other: 'configs', like: 'user and passwd' }
   end
 
-  def test_configure_defaults_to_snowflake
-    Olaf.configure(random: 'stuff')
-
-    assert Olaf.instance.is_a?(Olaf::Snowflake)
+  def test_configure_requires_a_driver
+    assert_raise ArgumentError do
+      Olaf.configure(random: 'stuff')
+    end
   end
 
   def test_configure_returns_the_default_driver
@@ -31,33 +31,33 @@ class OlafConfigureTest < Test::Unit::TestCase
   end
 
   def test_configure_registers_several_drivers
-    snowflake = MockDriver.new
+    postgres = MockDriver.new
     big_query = MockDriver.new
 
-    Olaf.configure(drivers: { snowflake: snowflake, big_query: big_query }, default: :snowflake)
+    Olaf.configure(drivers: { postgres: postgres, big_query: big_query }, default: :postgres)
 
-    assert_equal Olaf.instance, snowflake
-    assert_equal Olaf.instance(:snowflake), snowflake
+    assert_equal Olaf.instance, postgres
+    assert_equal Olaf.instance(:postgres), postgres
     assert_equal Olaf.instance(:big_query), big_query
   end
 
   def test_configure_defaults_to_the_first_driver_registered
-    snowflake = MockDriver.new
+    postgres = MockDriver.new
 
-    Olaf.configure(drivers: { snowflake: snowflake, big_query: MockDriver.new })
+    Olaf.configure(drivers: { postgres: postgres, big_query: MockDriver.new })
 
-    assert_equal Olaf.instance, snowflake
+    assert_equal Olaf.instance, postgres
   end
 
   def test_configure_rejects_a_default_that_was_not_registered
     assert_raise_message(/Unknown default driver :redshift/) do
-      Olaf.configure(drivers: { snowflake: MockDriver.new }, default: :redshift)
+      Olaf.configure(drivers: { postgres: MockDriver.new }, default: :redshift)
     end
   end
 
   def test_configure_rejects_both_forms_at_once
     assert_raise ArgumentError do
-      Olaf.configure(olaf_driver: MockDriver, drivers: { snowflake: MockDriver.new })
+      Olaf.configure(olaf_driver: MockDriver, drivers: { postgres: MockDriver.new })
     end
   end
 
@@ -74,7 +74,7 @@ class OlafConfigureTest < Test::Unit::TestCase
   end
 
   def test_instance_raises_for_a_driver_that_was_not_registered
-    Olaf.configure(drivers: { snowflake: MockDriver.new, big_query: MockDriver.new })
+    Olaf.configure(drivers: { postgres: MockDriver.new, big_query: MockDriver.new })
 
     assert_raise Olaf::UnknownDriverError do
       Olaf.instance(:redshift)

data/test/olaf_execute_test.rb

@@ -81,7 +81,7 @@ class OlafExecuteTest < Test::Unit::TestCase
     default_driver = RecordingDriver.new
     other_driver = RecordingDriver.new
 
-    Olaf.configure(drivers: { big_query: other_driver, snowflake: default_driver }, default: :snowflake)
+    Olaf.configure(drivers: { big_query: other_driver, postgres: default_driver }, default: :postgres)
 
     Olaf.execute(@query_instance)
 
@@ -98,7 +98,7 @@ class OlafExecuteTest < Test::Unit::TestCase
   end
 
   def test_execute_raises_when_the_driver_declared_is_not_configured
-    Olaf.configure(drivers: { default: RecordingDriver.new, snowflake: RecordingDriver.new })
+    Olaf.configure(drivers: { default: RecordingDriver.new, postgres: RecordingDriver.new })
 
     @query.driver :big_query
 

data/test/olaf_lazy_loading_test.rb

@@ -12,15 +12,13 @@ class OlafLazyLoadingTest < Test::Unit::TestCase
     assert_equal loaded_after('require "olaf"; Olaf.configure(olaf_driver: Olaf::Fake)'), []
   end
 
-  def test_configuring_the_snowflake_driver_loads_sequel_only
-    assert_equal loaded_after('require "olaf"; Olaf.configure(user: "olaf")'), ['sequel']
+  def test_configuring_the_big_query_driver_loads_its_client_only
+    assert_equal loaded_after('require "olaf"; Olaf.configure(olaf_driver: Olaf::BigQuery)'), ['google-cloud-bigquery']
   end
 
   private
 
   DEPENDENCIES = {
-    'sequel' => 'Sequel',
-    'odbc_utf8' => 'ODBC',
     'google-cloud-bigquery' => 'Google::Cloud::Bigquery'
   }.freeze
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: olaf
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Emiliano Mancuso
 bindir: bin
 cert_chain: []
-date: 2026-09-03 00:00:00.000000000 Z
+date: 2026-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-cloud-bigquery
@@ -23,20 +23,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.64'
-- !ruby/object:Gem::Dependency
-  name: sequel
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.37'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.37'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
@@ -62,7 +48,6 @@ files:
 - lib/olaf.rb
 - lib/olaf/drivers/big_query.rb
 - lib/olaf/drivers/fake.rb
-- lib/olaf/drivers/snowflake.rb
 - lib/olaf/errors.rb
 - lib/olaf/query_definition.rb
 - lib/olaf/query_definition/class_methods.rb
@@ -90,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:

data/lib/olaf/drivers/snowflake.rb

@@ -1,28 +0,0 @@
-require 'sequel'
-
-module Olaf
-  class Snowflake
-    WRAPPED_ERRORS = [Sequel::DatabaseError].freeze
-
-    def initialize(**config)
-      @config = config
-    end
-
-    def fetch(olaf_query)
-      conn.fetch(olaf_query.sql_template, **olaf_query.variables).all
-    rescue *WRAPPED_ERRORS => error
-      raise QueryExecutionError.new(error.message, olaf_query)
-    end
-
-    private
-
-    def conn
-      # Only opening a connection needs the ODBC system library.
-      @conn ||= begin
-        require 'odbc_utf8'
-
-        Sequel.odbc('snowflake', **@config)
-      end
-    end
-  end
-end