webhookdb 1.3.1 → 1.5.0

data/lib/webhookdb/apps.rb

@@ -15,6 +15,8 @@ require "webhookdb/service"
 require "webhookdb/api/auth"
 require "webhookdb/api/db"
 require "webhookdb/api/demo"
+require "webhookdb/api/error_handlers"
+require "webhookdb/api/icalproxy"
 require "webhookdb/api/install"
 require "webhookdb/api/me"
 require "webhookdb/api/organizations"
@@ -77,6 +79,8 @@ module Webhookdb::Apps
     mount Webhookdb::API::Auth
     mount Webhookdb::API::Db
     mount Webhookdb::API::Demo
+    mount Webhookdb::API::ErrorHandlers
+    mount Webhookdb::API::Icalproxy
     mount Webhookdb::API::Install
     mount Webhookdb::API::Me
     mount Webhookdb::API::Organizations

data/lib/webhookdb/async/autoscaler.rb

@@ -28,6 +28,7 @@ module Webhookdb::Async::Autoscaler
     setting :hostname_regex, /^web\.1$/, convert: ->(s) { Regexp.new(s) }
     setting :heroku_app_id_or_app_name, "", key: "HEROKU_APP_NAME"
     setting :heroku_formation_id_or_formation_type, "worker"
+    setting :sentry_alert_interval, 180
 
     after_configured do
       self._check_provider!
@@ -65,6 +66,7 @@ module Webhookdb::Async::Autoscaler
         latency_restored_threshold: self.latency_restored_threshold,
         latency_restored_handlers: [self.method(:scale_down)],
         log: ->(level, msg, kw={}) { self.logger.send(level, msg, kw) },
+        on_unhandled_exception: ->(e) { Sentry.capture_exception(e) },
       )
       return @instance.start
     end
@@ -78,10 +80,18 @@ module Webhookdb::Async::Autoscaler
       scale_action = @impl.scale_up(names_and_latencies, depth:, duration:, **)
       kw = {queues: names_and_latencies, depth:, duration:, scale_action:}
       self.logger.warn("high_latency_queues_event", **kw)
+      self._alert_sentry_latency(kw)
+    end
+
+    def _alert_sentry_latency(kw)
+      call_sentry = @last_called_sentry.nil? ||
+        @last_called_sentry < (Time.now - self.sentry_alert_interval)
+      return unless call_sentry
       Sentry.with_scope do |scope|
         scope&.set_extras(**kw)
         Sentry.capture_message("Some queues have a high latency")
       end
+      @last_called_sentry = Time.now
     end
 
     def scale_down(depth:, duration:, **)

data/lib/webhookdb/async/job.rb

@@ -14,5 +14,9 @@ module Webhookdb::Async::Job
     def with_log_tags(tags, &)
       Webhookdb::Async::JobLogger.with_log_tags(tags, &)
     end
+
+    def set_job_tags(tags)
+      Webhookdb::Async::JobLogger.set_job_tags(**tags)
+    end
   end
 end

data/lib/webhookdb/async/scheduled_job.rb

@@ -14,5 +14,9 @@ module Webhookdb::Async::ScheduledJob
     def with_log_tags(tags, &)
       Webhookdb::Async::JobLogger.with_log_tags(tags, &)
     end
+
+    def set_job_tags(**tags)
+      Webhookdb::Async::JobLogger.set_job_tags(**tags)
+    end
   end
 end

data/lib/webhookdb/async.rb

@@ -2,6 +2,7 @@
 
 require "amigo/retry"
 require "amigo/durable_job"
+require "amigo/job_in_context"
 require "amigo/rate_limited_error_handler"
 require "appydays/configurable"
 require "appydays/loggable"
@@ -62,6 +63,7 @@ module Webhookdb::Async
           ttl: self.error_reporting_ttl,
         )
         config.death_handlers << Webhookdb::Async::JobLogger.method(:death_handler)
+        config.server_middleware.add(Amigo::JobInContext::ServerMiddleware)
         config.server_middleware.add(Amigo::DurableJob::ServerMiddleware)
         # We use the dead set to move jobs that we need to retry manually
         config.options[:dead_max_jobs] = 999_999_999

data/lib/webhookdb/backfiller.rb

@@ -88,16 +88,29 @@ class Webhookdb::Backfiller
       return k, inserting
     end
 
+    # Return the conditional update expression.
+    # Usually this is:
+    # - +nil+ if +conditional_upsert?+ is false.
+    # - the +_update_where_expr+ if +conditional_upsert?+ is true.
+    # - Can be overridden by a subclass if they need to use a specific conditional update expression
+    #   in certain cases (should be rare).
+    def update_where_expr = self.conditional_upsert? ? self.upserting_replicator._update_where_expr : nil
+
+    # The upsert 'UPDATE' expression, calculated using the first row of a multi-row upsert.
+    # Defaults to +_upsert_update_expr+, but may need to be overridden in rare cases.
+    def upsert_update_expr(first_inserting_row) = self.upserting_replicator._upsert_update_expr(first_inserting_row)
+
     def flush_pending_inserts
       return if self.dry_run?
       return if self.pending_inserts.empty?
       rows_to_insert = self.pending_inserts.values
-      update_where = self.conditional_upsert? ? self.upserting_replicator._update_where_expr : nil
+      update_where_expr = self.update_where_expr
+      update_expr = self.upserting_replicator._upsert_update_expr(rows_to_insert.first)
       self.upserting_replicator.admin_dataset(timeout: :fast) do |ds|
         insert_ds = ds.insert_conflict(
-          target: self.upserting_replicator._remote_key_column.name,
-          update: self.upserting_replicator._upsert_update_expr(rows_to_insert.first),
-          update_where:,
+          target: self.upserting_replicator._upsert_conflict_target,
+          update: update_expr,
+          update_where: update_where_expr,
         )
         insert_ds.multi_insert(rows_to_insert)
       end

data/lib/webhookdb/concurrent.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Webhookdb::Concurrent
+  class Timeout < Timeout::Error; end
+
+  # Baseclass for pools for doing work across threads.
+  # Note that these concurrent pools are not for repeated use,
+  # like a normal threadpool. They are for 'fanning out' a single operation
+  # across multiple threads.
+  #
+  # Tasks should not error; if they error, the pool will becomes inoperable:
+  # +post+ and +join+ will re-raise the first task error.
+  class Pool
+    # Add work to the pool.
+    # Will block if no workers are free.
+    # Re-raises the pool's error if the pool has an error.
+    # This is important as we don't want the caller to keep adding work,
+    # if the pool is inoperable.
+    def post(&) = raise NotImplementedError
+
+    # Wait for all work to finish.
+    # Re-raise the first exception for any pool error.
+    def join = raise NotImplementedError
+  end
+
+  # Fake +Pool+ that does work in the calling thread,
+  # but behaves like a threaded pool (ie, tasks do not raise).
+  class SerialPool < Pool
+    def post
+      raise @exception if @exception
+      begin
+        yield
+      rescue StandardError => e
+        @exception = e
+      end
+    end
+
+    def join
+      raise @exception if @exception
+    end
+  end
+
+  # Pool that does work across a given number of threads.
+  # +queue_size+ is how many items can be in the queue before +post+ blocks.
+  # +threads+ defaults to +queue_size+, allowing at most +queue_size+ concurrent work,
+  # which fits the idea of a parallelized pool well.
+  #
+  # If you want the calling thread to queue up a bunch of work ahead of time,
+  # you can use a +Concurrent::ThreadPoolExecutor+. This pool will not allow the enqueing of more work
+  # while the queue is full.
+  class ParallelizedPool < Pool
+    def initialize(queue_size, timeout: nil, threads: nil)
+      super()
+      threads ||= queue_size
+      @timeout = timeout
+      @threads = (1..threads).map do
+        Thread.new do
+          loop { break unless self.do_work }
+        end
+      end
+      @queue = Thread::SizedQueue.new(queue_size)
+      @exception = nil
+    end
+
+    protected def do_work
+      task = @queue.pop
+      return false if task.nil?
+      if task == STOP
+        @queue.close
+        return false
+      end
+      begin
+        task.call
+      rescue StandardError => e
+        @exception ||= e
+        return false
+      end
+      return true
+    end
+
+    def post(&task)
+      raise @exception if @exception
+      added = @queue.push(task, timeout: @timeout)
+      raise Timeout, "waited #{@timeout} to add to the queue" if added.nil?
+      return true
+    end
+
+    def join
+      @queue.push(STOP)
+      @threads.each(&:join)
+      raise @exception if @exception
+    end
+
+    STOP = :stop
+  end
+end

data/lib/webhookdb/connection_cache.rb

@@ -45,13 +45,16 @@ class Webhookdb::ConnectionCache
   extend Webhookdb::MethodUtilities
   include Webhookdb::Dbutil
 
-  class ReentranceError < StandardError; end
+  class ReentranceError < Webhookdb::ProgrammingError; end
 
   configurable(:connection_cache) do
     # If this many seconds has elapsed since the last connecton was borrowed,
     # prune connections with no pending borrows.
     setting :prune_interval, 120
 
+    # If a connection hasn't been used in this long, validate it before reusing it.
+    setting :idle_timeout, 20.minutes
+
     # Seconds for the :fast timeout option.
     setting :timeout_fast, 30
     # Seconds for the :slow timeout option.
@@ -83,6 +86,25 @@ class Webhookdb::ConnectionCache
     @last_pruned_at = Time.now
   end
 
+  Available = Struct.new(:connection, :at) do
+    delegate :disconnect, to: :connection
+
+    # Return +connection+ if it has not been idle long enough,
+    # or if it has been idle, then validate it (SELECT 1), and return +connection+
+    # if it's valid, or +nil+ if the database disconnected it.
+    def validated_connection
+      needs_validation_at = self.at + Webhookdb::ConnectionCache.idle_timeout
+      return self.connection if needs_validation_at > Time.now
+      begin
+        self.connection << "SELECT 1"
+        return self.connection
+      rescue Sequel::DatabaseDisconnectError
+        self.connection.disconnect
+        return nil
+      end
+    end
+  end
+
   # Connect to the database at the given URL.
   # borrow is not re-entrant, so if the current thread already owns a connection
   # to the given url, raise a ReentrantError.
@@ -111,23 +133,48 @@ class Webhookdb::ConnectionCache
         raise ReentranceError,
               "ConnectionCache#borrow is not re-entrant for the same database since the connection has stateful config"
       end
-      conn = db_loans[:available].pop || take_conn(url, single_threaded: true, extensions: [:pg_json, :pg_streaming])
+      if (available = db_loans[:available].pop)
+        # If the connection doesn't validate, it won't be in :available at this point, so don't worry about it.
+        conn = available.validated_connection
+      end
+      conn ||= take_conn(url, single_threaded: true, extensions: [:pg_json, :pg_streaming])
       db_loans[:loaned][t] = conn
     end
-    conn << "SET statement_timeout TO #{timeout * 1000}" if timeout.present?
-    conn << "BEGIN;" if transaction
+    trash_conn = false
     begin
-      result = yield conn
-      conn << "COMMIT;" if transaction
-    rescue Sequel::DatabaseError
-      conn << "ROLLBACK;" if transaction
+      # All database operations need global handling to ensure property pool management.
+      conn << "SET statement_timeout TO #{timeout * 1000}" if timeout.present?
+      conn << "BEGIN;" if transaction
+      begin
+        result = yield conn
+        conn << "COMMIT;" if transaction
+      rescue Sequel::DatabaseError => e
+        # Roll back on any database error; but if we're disconnected, don't bother
+        # since we know the rollback won't reach the database.
+        conn << "ROLLBACK;" if transaction && !e.is_a?(Sequel::DatabaseDisconnectError)
+        raise
+      end
+    rescue Sequel::DatabaseDisconnectError
+      # If we're disconnected, trash this connection rather than re-adding it back to the pool.
+      trash_conn = true
       raise
     ensure
-      conn << "SET statement_timeout TO 0" if timeout.present?
+      reraise = nil
+      if timeout.present?
+        begin
+          # If the timeout fails for whatever reason, assume the connection is toast
+          # and don't return it to the pool.
+          conn << "SET statement_timeout TO 0"
+        rescue Sequel::DatabaseError => e
+          reraise = e
+          trash_conn = true
+        end
+      end
       @mutex.synchronize do
         @dbs_for_urls[url][:loaned].delete(t)
-        @dbs_for_urls[url][:available] << conn
+        @dbs_for_urls[url][:available] << Available.new(conn, Time.now) unless trash_conn
       end
+      raise reraise if reraise
     end
     self.prune(url) if now > self.next_prune_at
     return result

data/lib/webhookdb/console.rb

@@ -5,7 +5,7 @@ require "webhookdb"
 module Webhookdb::Console
   extend Webhookdb::MethodUtilities
 
-  class Error < StandardError; end
+  class Error < Webhookdb::WebhookdbError; end
 
   class UnsafeOperation < Error; end
 

data/lib/webhookdb/customer/reset_code.rb

@@ -6,7 +6,7 @@ require "webhookdb/postgres"
 require "webhookdb/customer"
 
 class Webhookdb::Customer::ResetCode < Webhookdb::Postgres::Model(:customer_reset_codes)
-  class Unusable < StandardError; end
+  class Unusable < Webhookdb::WebhookdbError; end
 
   TOKEN_LENGTH = 6
 

data/lib/webhookdb/customer.rb

@@ -10,14 +10,15 @@ require "webhookdb/demo_mode"
 class Webhookdb::Customer < Webhookdb::Postgres::Model(:customers)
   extend Webhookdb::MethodUtilities
   include Appydays::Configurable
+  include Webhookdb::Admin::Linked
 
-  class InvalidPassword < StandardError; end
-  class SignupDisabled < StandardError; end
+  class InvalidPassword < Webhookdb::WebhookdbError; end
+  class SignupDisabled < Webhookdb::WebhookdbError; end
 
   configurable(:customer) do
-    setting :signup_email_allowlist, ["*"], convert: ->(s) { s.split }
+    setting :signup_email_allowlist, ["*"], convert: lambda(&:split)
     setting :skip_authentication, false
-    setting :skip_authentication_allowlist, [], convert: ->(s) { s.split }
+    setting :skip_authentication_allowlist, [], convert: lambda(&:split)
   end
 
   # The bcrypt hash cost. Changing this would invalidate all passwords!

data/lib/webhookdb/database_document.rb

@@ -10,7 +10,7 @@ class Webhookdb::DatabaseDocument < Webhookdb::Postgres::Model(:database_documen
   include Appydays::Configurable
   configurable(:database_document) do
     setting :skip_authentication, false
-    setting :skip_authentication_allowlist, [], convert: ->(s) { s.split }
+    setting :skip_authentication_allowlist, [], convert: lambda(&:split)
   end
 
   plugin :column_encryption do |enc|

data/lib/webhookdb/db_adapter/default_sql.rb

@@ -8,20 +8,7 @@ module Webhookdb::DBAdapter::DefaultSql
     return s
   end
 
-  def create_table_sql(table, columns, if_not_exists: false)
-    createtable = +"CREATE TABLE "
-    createtable << "IF NOT EXISTS " if if_not_exists
-    createtable << self.qualify_table(table)
-    lines = ["#{createtable} ("]
-    columns[0...-1]&.each { |c| lines << "  #{self.column_create_sql(c)}," }
-    lines << "  #{self.column_create_sql(columns.last)}"
-    lines << ")"
-    return lines.join("\n")
-  end
-
-  def identifier_quote_char
-    raise NotImplementedError
-  end
+  def identifier_quote_char = raise NotImplementedError
 
   # We write our own escaper because we want to only escape what's needed;
   # otherwise we want to avoid quoting identifiers.

data/lib/webhookdb/db_adapter/partition.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Webhookdb::DBAdapter::Partition < Webhookdb::TypedStruct
+  attr_reader :parent_table, :partition_name, :suffix
+
+  def initialize(**kwargs)
+    super
+    self.typecheck!(:parent_table, Webhookdb::DBAdapter::Table)
+    self.typecheck!(:partition_name, Symbol)
+    self.typecheck!(:suffix, Symbol)
+  end
+
+  def partition_table = Webhookdb::DBAdapter::Table.new(name: self.partition_name, schema: self.parent_table.schema)
+end

data/lib/webhookdb/db_adapter/partitioning.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Webhookdb::DBAdapter::Partitioning < Webhookdb::TypedStruct
+  HASH = :hash
+  RANGE = :range
+
+  attr_reader :by, :column
+end

data/lib/webhookdb/db_adapter/pg.rb

@@ -11,9 +11,7 @@ class Webhookdb::DBAdapter::PG < Webhookdb::DBAdapter
   VERIFY_TIMEOUT = 2
   VERIFY_STATEMENT = "SELECT 1"
 
-  def identifier_quote_char
-    return '"'
-  end
+  def identifier_quote_char = '"'
 
   def create_index_sql(index, concurrently:)
     tgts = index.targets.map { |c| self.escape_identifier(c.name) }.join(", ")
@@ -26,7 +24,72 @@ class Webhookdb::DBAdapter::PG < Webhookdb::DBAdapter
     return "CREATE#{uniq} INDEX#{concurrent} IF NOT EXISTS #{idxname} ON #{tblname} (#{tgts})#{where}"
   end
 
-  def column_create_sql(column)
+  def create_index_sqls(index, concurrently:, partitions: [])
+    return super if partitions.empty?
+    result = []
+    result << self.create_index_sql(index, concurrently: false).gsub(" ON ", " ON ONLY ")
+    partitions.each do |partition|
+      partition_idx = index.change(table: partition.partition_table, name: "#{index.name}#{partition.suffix}")
+      result << self.create_index_sql(partition_idx, concurrently:)
+      result << "ALTER INDEX #{index.name} ATTACH PARTITION #{partition_idx.name}"
+    end
+    return result
+  end
+
+  def create_table_sql(table, columns, if_not_exists: false, partition: nil)
+    columns = columns.to_a
+    createtable = +"CREATE TABLE "
+    createtable << "IF NOT EXISTS " if if_not_exists
+    createtable << self.qualify_table(table)
+
+    partitioned_pks = []
+    partitioned_uniques = []
+    if partition
+      # We cannot use PRIMARY KEY or UNIQUE when partitioning,
+      # so set those columns as if they're not
+      columns.each_with_index do |c, i|
+        if c.pk?
+          # Set the type to the serial type as if it's a normal PK
+          type = case c.type
+            when BIGINT
+              :bigserial
+            when INTEGER
+              :serial
+            else
+              c.type
+          end
+          columns[i] = c.change(pk: false, type:)
+          partitioned_pks << c
+        elsif c.unique?
+          columns[i] = c.change(unique: false)
+          partitioned_uniques << c
+        end
+      end
+    end
+    tbl_lines = columns.map { |c| self.create_column_sql(c) }
+    tbl_lines.concat(partitioned_pks.map do |c|
+      pkcols = [partition.column, c.name].uniq.join(", ")
+      "PRIMARY KEY (#{pkcols})"
+    end)
+    tbl_lines.concat(partitioned_uniques.map { |c| "UNIQUE (#{partition.column}, #{c.name})" })
+    lines = ["#{createtable} ("]
+    lines << ("  " + tbl_lines.join(",\n  "))
+    lines << ")"
+    if partition
+      m = case partition.by
+        when Webhookdb::DBAdapter::Partitioning::HASH
+          "HASH"
+        when Webhookdb::DBAdapter::Partitioning::RANGE
+          "RANGE"
+        else
+          raise ArgumentError, "unknown partition method: #{partition.by}"
+      end
+      lines << "PARTITION BY #{m} (#{partition.column})"
+    end
+    return lines.join("\n")
+  end
+
+  def create_column_sql(column)
     modifiers = +""
     coltype = COLTYPE_MAP.fetch(column.type)
     if column.pk?
@@ -42,8 +105,15 @@ class Webhookdb::DBAdapter::PG < Webhookdb::DBAdapter
     return "#{colname} #{coltype}#{modifiers}"
   end
 
+  def create_hash_partition_sql(table, partition_count, remainder)
+    tbl = self.qualify_table(table)
+    s = "CREATE TABLE #{tbl}_#{remainder} PARTITION OF #{tbl} " \
+        "FOR VALUES WITH (MODULUS #{partition_count}, REMAINDER #{remainder})"
+    return s
+  end
+
   def add_column_sql(table, column, if_not_exists: false)
-    c = self.column_create_sql(column)
+    c = self.create_column_sql(column)
     ifne = if_not_exists ? " IF NOT EXISTS" : ""
     return "ALTER TABLE #{self.qualify_table(table)} ADD COLUMN#{ifne} #{c}"
   end
@@ -92,5 +162,7 @@ class Webhookdb::DBAdapter::PG < Webhookdb::DBAdapter
     TEXT_ARRAY => "text[]",
     TIMESTAMP => "timestamptz",
     UUID => "uuid",
+    :serial => "serial",
+    :bigserial => "bigserial",
   }.freeze
 end

data/lib/webhookdb/db_adapter/snowflake.rb

@@ -28,10 +28,21 @@ class Webhookdb::DBAdapter::Snowflake < Webhookdb::DBAdapter
   end
 
   def create_index_sql(*)
-    raise NotImplementedError, "Snowflake does not support indices"
+    raise Webhookdb::InvalidPrecondition, "Snowflake does not support indices"
   end
 
-  def column_create_sql(column)
+  def create_table_sql(table, columns, if_not_exists: false, **)
+    createtable = +"CREATE TABLE "
+    createtable << "IF NOT EXISTS " if if_not_exists
+    createtable << self.qualify_table(table)
+    lines = ["#{createtable} ("]
+    columns[0...-1]&.each { |c| lines << "  #{self.create_column_sql(c)}," }
+    lines << "  #{self.create_column_sql(columns.last)}"
+    lines << ")"
+    return lines.join("\n")
+  end
+
+  def create_column_sql(column)
     modifiers = +""
     if column.unique?
       modifiers << " UNIQUE NOT NULL"
@@ -44,7 +55,7 @@ class Webhookdb::DBAdapter::Snowflake < Webhookdb::DBAdapter
   end
 
   def add_column_sql(table, column, if_not_exists: false)
-    c = self.column_create_sql(column)
+    c = self.create_column_sql(column)
     # Snowflake has no 'ADD COLUMN IF NOT EXISTS' so we need to query the long way around
     add_sql = "ALTER TABLE #{self.qualify_table(table)} ADD COLUMN #{c}"
     return add_sql unless if_not_exists
@@ -118,9 +129,7 @@ class Webhookdb::DBAdapter::Snowflake < Webhookdb::DBAdapter
     conn.execute(statement)
   end
 
-  def identifier_quote_char
-    return ""
-  end
+  def identifier_quote_char = ""
 
   COLTYPE_MAP = {
     BIGINT => "bigint",

data/lib/webhookdb/db_adapter.rb

@@ -2,8 +2,10 @@
 
 class Webhookdb::DBAdapter
   require "webhookdb/db_adapter/column_types"
+  require "webhookdb/db_adapter/partition"
+  require "webhookdb/db_adapter/partitioning"
 
-  class UnsupportedAdapter < StandardError; end
+  class UnsupportedAdapter < Webhookdb::ProgrammingError; end
 
   VALID_IDENTIFIER = /^[a-zA-Z][a-zA-Z\d_ ]*$/
   INVALID_IDENTIFIER_PROMPT =
@@ -149,21 +151,41 @@ class Webhookdb::DBAdapter
     raise NotImplementedError
   end
 
+  # Return the CREATE TABLE sql to create table with columns.
   # @param [Table] table
   # @param [Array<Column>] columns
   # @param [Schema] schema
-  # @param [Boolean] if_not_exists
+  # @param [TrueClass,FalseClass] if_not_exists If true, use CREATE TABLE IF NOT EXISTS.
+  # @param partition [Webhookdb::DBAdapter::Partitioning,nil] If provided,
+  #   adds a "PARTITION BY HASH (partition_column_name)" to the returned SQL.
   # @return [String]
-  def create_table_sql(table, columns, schema: nil, if_not_exists: false)
+  def create_table_sql(table, columns, schema: nil, if_not_exists: false, partition: nil)
     raise NotImplementedError
   end
 
+  # We write our own escaper because we want to only escape what's needed;
+  # otherwise we want to avoid quoting identifiers.
+  def escape_identifier(s) = raise NotImplementedError
+
   # @param [Index] index
   # @return [String]
   def create_index_sql(index, concurrently:)
     raise NotImplementedError
   end
 
+  # Create indices, including for partitions.
+  # By default, just call create_index_sql and return it in a single-item array.
+  # Override if creating indices while using partitions requires extra logic.
+  # @param partitions [Array<Webhookdb::DBAdapter::Partition>]
+  # @return [Array<String>]
+  def create_index_sqls(index, concurrently:, partitions: [])
+    _ = partitions
+    return [self.create_index_sql(index, concurrently:)]
+  end
+
+  # @param column [Column] The column to create SQL for.
+  def create_column_sql(column) = raise NotImplementedError
+
   # @param [Table] table
   # @param [Column] column
   # @param [Boolean] if_not_exists

data/lib/webhookdb/dbutil.rb

@@ -35,6 +35,7 @@ module Webhookdb::Dbutil
               4
             end)
     setting :pool_timeout, 10
+    setting :pool_class, :timed_queue
     # Set to 'disable' to work around segfault.
     # See https://github.com/ged/ruby-pg/issues/538
     setting :gssencmode, ""
@@ -70,6 +71,7 @@ module Webhookdb::Dbutil
     res[:log_warn_duration] ||= Webhookdb::Dbutil.slow_query_seconds
     res[:max_connections] ||= Webhookdb::Dbutil.max_connections
     res[:pool_timeout] ||= Webhookdb::Dbutil.pool_timeout
+    res[:pool_class] ||= Webhookdb::Dbutil.pool_class
     res[:driver_options] = {}
     (res[:driver_options][:gssencmode] = Webhookdb::Dbutil.gssencmode) if Webhookdb::Dbutil.gssencmode.present?
     return res