pg_pipeline 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b73820c432250a5622916f522cc7df96e9be218120372d90d30447b2ea4364f
-  data.tar.gz: af6ac07e07a30e7812846c58b56cfb3fcf0722b6fcac99119be4529249a92a0f
+  metadata.gz: 750bfa3d5740056066f5a3543e747f02701132ab941aabbd828d25ece368b1df
+  data.tar.gz: f822719ac13016e6a5e8fc373f6fcaf625cd97cc128cf9322a1231228d20ad40
 SHA512:
-  metadata.gz: 70249da4404588815fd9b5122ad3bcd564ca8fb8deec8f9068788a27bad9427ebac189bb7ee3ae9f0e05c0461429a00c2a70001749d62f11199777a1d3394472
-  data.tar.gz: b030ef64f18383b8d3fd15177f7375b7347fed99e7e2e2dc387133306a35fccbe775a79aa8545005fef3bffc7d8ed1ba9547a389212de9a3c8801c0558a0d24e
+  metadata.gz: d7ea51781dc5150133a1f04d8c65ac2b57bc39df6de98f34534e6e490359dcb1b4f19684c2a950f6a22e138ef2d1ca17c4e034df961140afbc4f37d1dab3c76a
+  data.tar.gz: 45c4e56417cfa97147db391f2150dba6c5dc0e01f957a373429ef5f6dd7c6ee4baa50973e0a93c179f480bbf3ad79c20d5a501b4e72e705a743cb16b921b4607

data/CHANGELOG.md

@@ -1,6 +1,86 @@
 # Changelog
 
-## [0.2.0] - unreleased
+## [0.2.2] - 2026-07-30
+
+Lifecycle-hardening release. Fixes five pool/task-ownership defects surfaced by
+review, adds input validation, and ships deterministic regression coverage for
+each fix.
+
+### Fixed (pool & task lifecycle)
+
+- Replacement pipeline drivers are now owned by the pool's stable parent task,
+  not the supervisor. Stopping the supervisor during shutdown can no longer
+  cascade-cancel a live replacement driver before it is gracefully drained.
+- Returning a pinned connection re-checks the closing state after the yielding
+  recycle step (`ROLLBACK`/`DISCARD ALL`/reconnect); a connection recycled while
+  a concurrent `abort!` runs is closed instead of leaked into the free list.
+- Task cancellation during pinned recycle (`Async::Cancel`/`Async::Stop` are
+  `Exception`s, not `StandardError`s) is caught solely to close the connection
+  and then re-raised, so cancellation semantics are preserved and the connection
+  is not leaked.
+- Nested `Client#session`/`Client#transaction` on the same task is rejected with
+  `RecursiveCheckoutError` before the pinned semaphore is acquired, preventing a
+  self-deadlock (`pinned_size: 1`) or a silently different connection
+  (`pinned_size > 1`). Use `Transaction#savepoint` for nested atomicity.
+- A closing or closed pool is terminal: `Pool#start` raises rather than
+  half-restarting onto stale driver state, including after an interrupted close.
+  Create a new pool instead.
+- Partial startup now also cleans up if spawning the supervisor task fails after
+  drivers were created.
+- Once shutdown begins, availability checks report `ShutdownError` before the
+  generic not-started state, preserving the definitely-not-dispatched failure
+  classification for concurrent submitters.
+
+### Changed (hardening)
+
+- Timing options (`reconnect_interval`, `reconnect_backoff_max`,
+  `health_interval`, `health_timeout`) reject negative, `NaN`, and infinite
+  values; `health_interval` additionally allows `0` ("probe every cycle").
+- The supervisor wakes on the shorter of the enabled reconnect/health cadences,
+  so a short `health_interval` is honored independently of a large
+  `reconnect_interval`, using scheduler-aware `Kernel#sleep` rather than the
+  deprecated `Async::Task#sleep` wrapper.
+- Reconnect backoff uses floating-point exponentiation and caps non-finite or
+  over-limit delays, avoiding giant integers without prematurely flattening the
+  backoff for very small base intervals.
+- `Transaction#open`/`#savepoint_seq` are no longer publicly writable; control
+  state is read via `#open?` and mutated only internally.
+- `Session#exec` accepts optional bind parameters (`exec(sql, params)`),
+  matching the documented API; any explicitly supplied params value, including
+  an empty array, uses `exec_params`, while omitted params keep simple-query mode.
+- Driver shutdown attempts every driver even if one close raises or the closing
+  task is cancelled, then re-raises cancellation after best-effort cleanup;
+  watcher cleanup still stops the writer when stopping the reader fails.
+- `Client#close`/`#abort!` now clear client lifecycle state even when terminal pool
+  cleanup reports an error, while a rejected re-entrant close leaves the live
+  client started.
+
+### Compatibility
+
+- Shutdown cleanup handles `Async::Cancel` explicitly. The supported dependency
+  floor (`async 2.42.0`) already defines that class, so no dead compatibility
+  fallback is required.
+- CI now runs the unit suite against exact `async 2.42.0`, builds ruby-pg against
+  source-built client libpq 14.23/16.14/17.10 and runs each build against a live
+  PostgreSQL server, plus a separate server integration matrix for 14/16/17/18.
+
+## [0.2.1]
+
+- SessionGuard: bounded per-SQL memo cache for unsafe_reason. Repeated SQL
+  (parameterized queries) now costs ~0 allocations instead of ~330 objects/call
+  (measured); eliminates the code_only/byteslice line that showed up in profiles.
+- Client#query: drop redundant sql dup (Request owns the one immutable copy).
+- PoolOps.select_driver: allocation-free least-loaded scan (was 2-3 arrays/call);
+  behavior verified identical across 20k random cases.
+- bench_kit/metrics.rb + rake bench:metrics: full picture in one run —
+  allocations/query + GC pressure, RubyProf process_time (CPU) and allocations,
+  RubyProf wall (sanity), and StackProf cpu/wall sampling. Asserts run outside
+  every profiler; warmup keeps connection setup out of frame.
+- profile_ci_scenario.rb: correctness asserts moved out of the profiled block;
+  GC.start before profiling.
+- Dev dependency: stackprof (~> 0.2).
+
+## [0.2.0]
 
 Initial experimental implementation.
 
@@ -103,7 +183,7 @@ Initial experimental implementation.
   even when the losing Request was already settled.
 - Strict guard precise denylist (no pg_typeof/setup/xact-advisory false positives).
 - CI separates server-major coverage from source-built client-libpq 14/16 coverage.
-- benchmarks/ (fiber-storm latency, multi-worker connection-count smoke).
+- `bench_kit/` (fiber-storm latency, multi-worker connection-count smoke).
 - Pool driver slot arrays self-heal size (reconnect/health safe under partial init).
 - Unit coverage: failover, health_probe, pinned cancel on abort.
 
@@ -138,19 +218,3 @@ Initial experimental implementation.
   boundary: cancellation during rollback/sanitize/reconnect closes the physical
   connection instead of orphaning it outside the pool. Graceful close also closes
   already-idle pinned sockets before waiting for active checkouts.
-
-## 0.2.1 (perf + measurement)
-
-- SessionGuard: bounded per-SQL memo cache for unsafe_reason. Repeated SQL
-  (parameterized queries) now costs ~0 allocations instead of ~330 objects/call
-  (measured); eliminates the code_only/byteslice line that showed up in profiles.
-- Client#query: drop redundant sql dup (Request owns the one immutable copy).
-- PoolOps.select_driver: allocation-free least-loaded scan (was 2-3 arrays/call);
-  behavior verified identical across 20k random cases.
-- bench_kit/metrics.rb + rake bench:metrics: full picture in one run —
-  allocations/query + GC pressure, RubyProf process_time (CPU) and allocations,
-  RubyProf wall (sanity), and StackProf cpu/wall sampling. Asserts run outside
-  every profiler; warmup keeps connection setup out of frame.
-- profile_ci_scenario.rb: correctness asserts moved out of the profiled block;
-  GC.start before profiling.
-- Dev dependency: stackprof (~> 0.2).

data/DESIGN.md

@@ -254,10 +254,10 @@ chunked-rows, non-blocking cancel), never a floor.
 - `SessionGuard` is policy/ergonomics, not a security boundary. `:strict` adds a
   precise denylist (`nextval`/`setval`/`pg_export_snapshot`, …) without the old
   broad `pg_*(` / `set*(` false positives; UDFs can still mutate session state.
-- Live integration covers **server** PG 14/16/17. CI prints the linked **client**
-  libpq version, but does not yet matrix distinct client-libpq majors (one
-  runner libpq across all server jobs). Pipeline capability is client-side, so
-  a dedicated libpq 14/16/17 client matrix remains future work.
+- Live integration covers **server** PG 14/16/17/18. A separate CI matrix
+  builds ruby-pg against source-built **client** libpq 14/16/17, asserts the
+  linked major, and runs both unit and live integration suites because pipeline
+  capability is determined by client libpq rather than server version.
 - On libpq 14–16, `place_sync` uses `PQpipelineSync` / ruby-pg `sync_pipeline_sync`
   (flush coupled); libpq 17+ uses `send_pipeline_sync` + explicit `sync_flush`.
 - Pinned recycle still runs full `DISCARD ALL` (no lighter reset profile / recycle
@@ -284,15 +284,15 @@ Implemented:
   live sibling; the failed Request object itself is never re-used.
 - `abort!` CancelRequest on in-use pinned connections.
 - Falcon per-worker contract + sizing formula; reactor-local Client fail-fast.
-- Packaging: gemspec metadata, CI (unit + PG server 14/16/17), docker-compose,
-  examples, `benchmarks/pipeline_bench.rb` + `benchmarks/multiworker_smoke.rb`.
+- Packaging: gemspec metadata, CI (unit + PG server 14/16/17/18 + client-libpq
+  14/16/17 + exact async floor), docker-compose,
+  examples, `bench_kit/pipeline_throughput.rb` + `bench_kit/multiworker_smoke.rb`.
 - Live integration suite (multiplex, isolation, cancel-drain, savepoints, stats,
   backpressure, pinned concurrency, indeterminate on abort, reconnect, backend
   terminate recovery, pinned abort cancel).
 
 Still open:
 
-- Dedicated client-libpq 14/16/17 CI matrix (not only server majors).
 - Lighter pinned reset / recycle-latency metrics under high-TPS tx.
 - Force socket close if pinned cancel is ignored.
 - Published bench numbers in README; tighten multiworker smoke to peak occupancy.

data/README.md

@@ -123,7 +123,7 @@ db.stats
 # }
 ```
 
-`load` (pending + in_flight) per driver is the head-of-line signal.
+`load` (pending + in-flight + submitting + dispatching) per driver is the routing/head-of-line signal.
 
 ## Failure model
 

data/lib/pg_pipeline/client.rb

@@ -144,16 +144,22 @@ module PgPipeline
       return unless started?(client)
 
       ensure_context!(client)
-      pool(client).graceful_close
-      client.__send__(:started=, false)
+      begin
+        pool(client).graceful_close
+      ensure
+        client.__send__(:started=, false) if pool(client).closing?
+      end
     end
 
     def abort!(client)
       return unless started?(client)
 
       ensure_context!(client)
-      pool(client).abort!
-      client.__send__(:started=, false)
+      begin
+        pool(client).abort!
+      ensure
+        client.__send__(:started=, false) if pool(client).closing?
+      end
     end
 
     def pool(client)

data/lib/pg_pipeline/connection_driver.rb

@@ -481,11 +481,17 @@ module PgPipeline
     end
 
     def stop_watchers(d)
-      d.reader_task&.stop
-      d.writer_task&.stop
+      reader = d.reader_task
+      writer = d.writer_task
       d.reader_task = nil
       d.writer_task = nil
-    rescue StandardError
+
+      [reader, writer].each do |task|
+        task&.stop
+      rescue Async::Cancel, StandardError
+        nil
+      end
+
       nil
     end
 

data/lib/pg_pipeline/errors.rb

@@ -10,6 +10,7 @@ module PgPipeline
   class IndeterminateResultError < ConnectionLostError; end
   class ShutdownError < Error; end
   class ProtocolError < Error; end
+  class RecursiveCheckoutError < Error; end
 
   class QueryError < Error
     attr_reader :cause_result

data/lib/pg_pipeline/pool.rb

@@ -18,6 +18,7 @@ module PgPipeline
     DEFAULT_HEALTH_INTERVAL = 10.0
     DEFAULT_HEALTH_TIMEOUT = 5.0
     DISCARD_SEQUENCES_SERVER_VERSION = 90_400
+    CANCEL_SIGNAL = Async::Cancel
 
     attr_reader :reconnects, :pipeline_size
 
@@ -39,11 +40,11 @@ module PgPipeline
       @max_pending = max_pending
       @max_in_flight = max_in_flight
       @reconnect = reconnect
-      @reconnect_interval = Float(reconnect_interval)
-      @reconnect_backoff_max = Float(reconnect_backoff_max)
+      @reconnect_interval = PoolOps.finite_float!(reconnect_interval, :reconnect_interval)
+      @reconnect_backoff_max = PoolOps.finite_float!(reconnect_backoff_max, :reconnect_backoff_max)
       @health_check = health_check
-      @health_interval = Float(health_interval)
-      @health_timeout = Float(health_timeout)
+      @health_interval = PoolOps.finite_float!(health_interval, :health_interval, allow_zero: true)
+      @health_timeout = PoolOps.finite_float!(health_timeout, :health_timeout)
       @cancel_pinned_on_abort = cancel_pinned_on_abort
 
       @drivers = []
@@ -55,6 +56,7 @@ module PgPipeline
       @health_failures = 0
       @supervisor_error = nil
       @supervisor = nil
+      @task_parent = nil
 
       @pinned_free = []
       @pinned_in_use = {}
@@ -66,10 +68,17 @@ module PgPipeline
 
       @started = false
       @closing = false
+      @closed = false
     end
 
-    def start(parent: Async::Task.current)
+    def start(parent: nil)
       raise Error, "pool already started" if @started
+      if @closing || @closed
+        raise ShutdownError, "pool is closing or was closed and cannot be restarted; create a new Pool"
+      end
+
+      parent ||= Async::Task.current
+      @task_parent = parent
 
       begin
         @pipeline_size.times { @drivers << start_pipeline_driver(parent) }
@@ -77,13 +86,13 @@ module PgPipeline
         @driver_attempts = Array.new(@drivers.size, 0)
         @driver_last_health = Array.new(@drivers.size, monotonic)
         @pinned_gate = Async::Semaphore.new(@pinned_size) if @pinned_size.positive?
+        @started = true
+        @supervisor = parent.async { supervise } if @reconnect || @health_check
       rescue Exception
         cleanup_partial_start
         raise
       end
 
-      @started = true
-      @supervisor = parent.async { supervise } if @reconnect || @health_check
       self
     end
 
@@ -103,6 +112,12 @@ module PgPipeline
       raise @pinned_error if @pinned_error
       raise Error, "pinned pool is disabled (pinned_size=0)" if @pinned_size.zero?
 
+      if @pinned_owners[Async::Task.current].positive?
+        raise RecursiveCheckoutError,
+              "nested Client#session/transaction on the same task is not allowed; " \
+              "use Transaction#savepoint for nested atomicity"
+      end
+
       @pinned_gate.acquire do
         raise @pinned_error if @pinned_error
         raise ShutdownError, "pool is closing" if @closing
@@ -143,6 +158,7 @@ module PgPipeline
         health_failures: @health_failures,
         supervisor_error: @supervisor_error&.message,
         closing: @closing,
+        closed: @closed,
         pinned_error: @pinned_error&.message
       }
     end
@@ -156,10 +172,24 @@ module PgPipeline
 
       @closing = true
       @started = false
-      stop_supervisor
-      @drivers.each(&:graceful_close)
-      wait_for_pinned_idle
-      close_free_pinned
+      first_error = nil
+
+      begin
+        first_error = preferred_shutdown_error(first_error, stop_supervisor)
+        first_error = preferred_shutdown_error(first_error, close_all_drivers(:graceful_close))
+
+        begin
+          wait_for_pinned_idle
+        rescue CANCEL_SIGNAL, StandardError => e
+          first_error = preferred_shutdown_error(first_error, e)
+        end
+      ensure
+        close_free_pinned
+        @closed = true
+      end
+
+      raise first_error if first_error
+
       nil
     end
 
@@ -168,31 +198,50 @@ module PgPipeline
 
       @closing = true
       @started = false
-      stop_supervisor
-      cancel_in_use_pinned if @cancel_pinned_on_abort
-      @drivers.each(&:abort!)
-      close_free_pinned
+      first_error = nil
+
+      begin
+        first_error = preferred_shutdown_error(first_error, stop_supervisor)
+        if @cancel_pinned_on_abort
+          first_error = preferred_shutdown_error(first_error, cancel_in_use_pinned)
+        end
+        first_error = preferred_shutdown_error(first_error, close_all_drivers(:abort!))
+      ensure
+        close_free_pinned
+        @closed = true
+      end
+
+      raise first_error if first_error
+
       nil
     end
 
     private
 
     def supervise
-      parent = Async::Task.current
       until @closing
         begin
-          reap_and_replace(parent) if @reconnect
+          reap_and_replace(@task_parent) if @reconnect
           health_probe if @health_check
           @supervisor_error = nil
         rescue StandardError => e
-          # Keep the loop alive: one probe/reconnect failure must not permanently
-          # disable health checks and replacement for the worker lifetime.
           @supervisor_error = e
         end
-        parent.sleep(@reconnect_interval)
+
+        break if @closing
+
+        sleep(supervisor_sleep_interval)
       end
     end
 
+    def supervisor_sleep_interval
+      candidates = []
+      candidates << @reconnect_interval if @reconnect
+      candidates << @health_interval if @health_check && @health_interval.positive?
+      interval = candidates.min || @reconnect_interval
+      interval.positive? ? interval : @reconnect_interval
+    end
+
     def reap_and_replace(parent)
       now = monotonic
       ensure_driver_slots!
@@ -242,28 +291,63 @@ module PgPipeline
     end
 
     def next_backoff(attempts)
-      delay = @reconnect_interval * (2**(attempts - 1))
-      delay < @reconnect_backoff_max ? delay : @reconnect_backoff_max
+      exponent = [Integer(attempts) - 1, 0].max
+      delay = @reconnect_interval * (2.0**exponent)
+      delay.finite? && delay < @reconnect_backoff_max ? delay : @reconnect_backoff_max
     end
 
     def cancel_in_use_pinned
+      cancellation = nil
+
       @pinned_in_use.keys.each do |conn|
         conn.cancel if conn.respond_to?(:cancel)
+      rescue CANCEL_SIGNAL => e
+        cancellation ||= e
       rescue StandardError
         nil
       end
+
+      cancellation
     end
 
     def stop_supervisor
-      @supervisor&.stop
+      supervisor = @supervisor
       @supervisor = nil
+      supervisor&.stop
+      nil
+    rescue CANCEL_SIGNAL => e
+      e
     rescue StandardError
       nil
     end
 
+    def close_all_drivers(method_name)
+      first_error = nil
+      cancellation = nil
+
+      @drivers.each do |driver|
+        begin
+          driver.public_send(method_name)
+        rescue CANCEL_SIGNAL => e
+          cancellation ||= e
+        rescue StandardError => e
+          first_error ||= e
+        end
+      end
+
+      cancellation || first_error
+    end
+
+    def preferred_shutdown_error(current, candidate)
+      return current unless candidate
+      return candidate if candidate.is_a?(CANCEL_SIGNAL)
+
+      current || candidate
+    end
+
     def ensure_available!
+      raise ShutdownError, "pool is closing or closed" if @closing || @closed
       raise Error, "pool not started" unless @started
-      raise ShutdownError, "pool is closing" if @closing
     end
 
     def start_pipeline_driver(parent)
@@ -282,7 +366,14 @@ module PgPipeline
             PoolOps.safe_close(conn)
           else
             recycled = recycle_pinned_connection(conn)
-            @pinned_free << recycled if recycled
+
+            if recycled
+              if @closing
+                PoolOps.safe_close(recycled)
+              else
+                @pinned_free << recycled
+              end
+            end
           end
         end
       ensure
@@ -301,6 +392,9 @@ module PgPipeline
 
       PoolOps.sanitize_pinned_connection(conn)
       conn
+    rescue CANCEL_SIGNAL
+      PoolOps.safe_close(conn)
+      raise
     rescue StandardError => cleanup_error
       PoolOps.safe_close(conn)
 
@@ -322,13 +416,20 @@ module PgPipeline
     def cleanup_partial_start
       @drivers.each do |driver|
         driver.abort!
-      rescue StandardError
+      rescue CANCEL_SIGNAL, StandardError
         nil
       end
       @drivers.clear
+      @driver_backoff.clear
+      @driver_attempts.clear
+      @driver_last_health.clear
       close_free_pinned
+      @pinned_gate = nil
+      @supervisor = nil
+      @task_parent = nil
       @started = false
       @closing = false
+      @closed = false
     end
 
     def close_free_pinned
@@ -351,6 +452,17 @@ module PgPipeline
       raise ArgumentError, "#{name} must be an integer >= 1"
     end
 
+    def finite_float!(value, name, allow_zero: false)
+      number = Float(value)
+      bound_ok = allow_zero ? number >= 0 : number.positive?
+      raise ArgumentError unless number.finite? && bound_ok
+
+      number
+    rescue ArgumentError, TypeError
+      requirement = allow_zero ? "non-negative finite" : "positive finite"
+      raise ArgumentError, "#{name} must be a #{requirement} number (got #{value.inspect})"
+    end
+
     def nonnegative_integer!(value, name)
       integer = Integer(value)
       raise ArgumentError, "#{name} must be >= 0" if integer.negative?

data/lib/pg_pipeline/session.rb

@@ -13,7 +13,7 @@ module PgPipeline
     end
 
     def query(sql, params = []) = SessionOps.query(self, sql, params)
-    def exec(sql) = SessionOps.exec(self, sql)
+    def exec(sql, params = nil) = SessionOps.exec(self, sql, params)
     def prepare(name, sql, param_types = nil) = SessionOps.prepare(self, name, sql, param_types)
     def exec_prepared(name, params = []) = SessionOps.exec_prepared(self, name, params)
     def active? = @active
@@ -39,9 +39,13 @@ module PgPipeline
       connection(session).exec_params(sql, params)
     end
 
-    def exec(session, sql)
+    def exec(session, sql, params = nil)
       ensure_active!(session)
-      connection(session).exec(sql)
+      if params.nil?
+        connection(session).exec(sql)
+      else
+        connection(session).exec_params(sql, params)
+      end
     end
 
     def prepare(session, name, sql, param_types)

data/lib/pg_pipeline/transaction.rb

@@ -6,8 +6,6 @@ require_relative "session"
 
 module PgPipeline
   class Transaction < Session
-    attr_accessor :open, :savepoint_seq
-
     def initialize(conn)
       super
       @open = false
@@ -23,6 +21,10 @@ module PgPipeline
     end
 
     def open? = @open
+
+    private
+
+    attr_accessor :open, :savepoint_seq
   end
 
   module TransactionOps
@@ -30,19 +32,17 @@ module PgPipeline
 
     def run(tx)
       SessionOps.ensure_active!(tx)
-      raise Error, "transaction is already open" if tx.open
+      raise Error, "transaction is already open" if tx.open?
 
       conn = SessionOps.connection(tx)
       conn.exec("BEGIN")
-      tx.open = true
+      tx.__send__(:open=, true)
       begin
         result = yield tx
         conn.exec("COMMIT")
-        tx.open = false
+        tx.__send__(:open=, false)
         result
       rescue Exception
-        # Only roll back the transaction we opened. Early guard errors
-        # ("already open", inactive handle) must not hit this path.
         rollback_quietly(tx)
         raise
       end
@@ -50,11 +50,12 @@ module PgPipeline
 
     def savepoint(tx, name)
       SessionOps.ensure_active!(tx)
-      raise Error, "savepoint requires an open transaction" unless tx.open
+      raise Error, "savepoint requires an open transaction" unless tx.open?
 
       conn = SessionOps.connection(tx)
-      tx.savepoint_seq += 1
-      point = name || "pgp_sp_#{tx.savepoint_seq}"
+      seq = tx.__send__(:savepoint_seq) + 1
+      tx.__send__(:savepoint_seq=, seq)
+      point = name || "pgp_sp_#{seq}"
       ident = conn.quote_ident(point)
 
       conn.exec("SAVEPOINT #{ident}")
@@ -79,14 +80,14 @@ module PgPipeline
     end
 
     def rollback_quietly(tx)
-      return unless tx.open
+      return unless tx.open?
 
       conn = SessionOps.connection(tx)
       conn&.exec("ROLLBACK")
     rescue PG::Error
       nil
     ensure
-      tx.open = false
+      tx.__send__(:open=, false)
     end
   end
 end

data/lib/pg_pipeline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgPipeline
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_pipeline
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Roman Hajdarov