active_pipeline 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 07b59b4a629962f09f8a6fde03fece7b3a4e1bcec69e3bf711657e83b1115360
+  data.tar.gz: fb6630f5e422714efae2314896925c2becb8f849f774446520ad7e8ff9ac83bd
+SHA512:
+  metadata.gz: 7a48549372312bfaa19cb0f21a7960ad93d9cb583db50a675263698683c336f1cfe0fcd70b7497ec0e16126ec7822bd39ab126fb14a10b37c3d0cf2d8350100b
+  data.tar.gz: d58eb657403ca873f1721ecb9700318abb2fea358a35be516f1980b3542ba905caa8d0009c4dd065c51080be5ea8d09df8b1c1b87fd9cde4ea276af15b586702

data/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Fixed
+- Statements without binds failed with `PQsendQuery not allowed in pipeline mode`.
+- Reading pipeline results ignored the per-statement `nil` terminators, so batches of more than one statement failed.
+- Inserts were missing `RETURNING "id"`, so created records had no primary key.
+- Writes hung forever when the worker was not started, had stopped, or the process had forked.
+- Worker crashes or connection failures could leave callers waiting forever; they are now always released.
+- Writes inside a materialized transaction escaped it (and could deadlock on row locks); they now run on the caller's connection.
+- Database errors are translated into the usual ActiveRecord classes (`RecordNotUnique`, `NotNullViolation`, ...).
+- Worker connections are configured like the application's (search path, timezone, variables) and follow the model's database in multi-database setups.
+- Nested `ActivePipeline.bypass` blocks restore the outer state.
+
+### Added
+- `max_batch_size` and `wait_timeout` settings.
+- `batch.active_pipeline` instrumentation event; pipelined statements are logged as `sql.active_record`.
+- `stop!` drains queued statements before shutting down.
+
+### Changed
+- Requires Ruby >= 3.2 and ActiveRecord >= 7.1.
+
+## [0.1.0]
+
+- Initial release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Carlos (Thrashattack) Cunha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,189 @@
+# ActivePipeline
+
+[![CI](https://github.com/thrashattack/active_pipeline/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/thrashattack/active_pipeline/actions/workflows/ci.yml)
+[![Coverage Status](https://coveralls.io/repos/github/Thrashattack/active_pipeline/badge.svg?branch=main)](https://coveralls.io/github/thrashattack/active_pipeline?branch=main)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE.txt)
+
+Transparent, Go-channel-like write batching for ActiveRecord on PostgreSQL.
+
+ActivePipeline intercepts the `INSERT`, `UPDATE` and `DELETE` statements issued by your
+threads (Sidekiq workers, multi-threaded Puma), buffers them for a short window and flushes
+them per table in a single round trip using
+[PostgreSQL pipeline mode](https://www.postgresql.org/docs/current/libpq-pipeline-mode.html).
+Each caller thread blocks until its own statement is resolved, so application code
+keeps the usual synchronous API: `create!` still returns a persisted record with its id,
+and `update_all` still returns the affected row count.
+
+If one statement in a batch fails, only that caller gets the error. The rest of the batch
+is retried and committed.
+
+## Table of contents
+
+- [How it works](#how-it-works)
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Configuration](#configuration)
+- [Transactions and tradeoffs](#transactions-and-tradeoffs)
+- [Instrumentation](#instrumentation)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
+
+## How it works
+
+```
+ Sidekiq threads                       ActivePipeline worker                 PostgreSQL
+ ───────────────                       ─────────────────────                 ──────────
+ User.create!  ─┐                    ┌─ group "users" ─ pipeline ─────────▶  BEGIN (implicit)
+ User.create!  ─┼─▶ queue ─ window ──┤    INSERT, INSERT, UPDATE ...          ...
+ Post.update!  ─┘   (IVar per call)  └─ group "posts" ─ pipeline ─────────▶  SYNC / COMMIT
+       ▲                                         │
+       └──────────── results / errors ───────────┘
+```
+
+1. A write on a PostgreSQL connection is wrapped in a payload and pushed onto a queue. The
+   calling thread then waits on a `Concurrent::IVar`.
+2. A background worker takes the first statement, keeps collecting for `batch_window_ms`
+   (or until `max_batch_size`), and groups the batch by database and table.
+3. Each group is sent through its own dedicated connection in pipeline mode as one implicit
+   transaction. Groups run in parallel.
+4. If a statement fails, PostgreSQL rolls the whole group back. ActivePipeline rejects
+   the failing statement and pipelines the remaining ones again.
+5. Callers wake up with the same values and the same exception classes
+   (`ActiveRecord::RecordNotUnique`, `ActiveRecord::NotNullViolation`, ...) that ActiveRecord
+   would have produced.
+
+## Requirements
+
+- Ruby >= 3.2
+- ActiveRecord >= 7.1 with the PostgreSQL adapter
+- `pg` >= 1.3, built against libpq >= 14 (pipeline mode)
+- PostgreSQL >= 14
+
+## Installation
+
+Add the gem to your application's Gemfile:
+
+```ruby
+gem "active_pipeline"
+```
+
+Then run:
+
+```sh
+bundle install
+```
+
+## Usage
+
+The pipeline only diverts writes while the worker is running. Start it in the processes
+where batching pays off. Sidekiq is the recommended place:
+
+```ruby
+# config/initializers/sidekiq.rb
+Sidekiq.configure_server do |config|
+  config.on(:startup)  { ActivePipeline.start! }
+  config.on(:shutdown) { ActivePipeline.stop! }
+end
+```
+
+In processes that never call `start!` (web servers, consoles, rake tasks), every write goes
+straight through ActiveRecord as usual.
+
+`stop!` drains the statements that are already queued before closing its connections. If
+the process forks after `start!`, call `start!` again in the child; the child never reuses
+the parent's worker.
+
+To force a block of code to skip the pipeline:
+
+```ruby
+ActivePipeline.bypass do
+  Order.transaction do
+    order.save!
+    order.line_items.each(&:save!)
+  end
+end
+```
+
+## Configuration
+
+```ruby
+# config/initializers/active_pipeline.rb
+ActivePipeline.configure do |config|
+  config.enabled         = true # master switch
+  config.batch_window_ms = 50   # how long to keep collecting after the first statement arrives
+  config.max_batch_size  = 500  # statements per flush
+  config.wait_timeout    = nil  # seconds a caller waits before ActivePipeline::TimeoutError (nil = forever)
+end
+```
+
+| Option            | Default | Description |
+|-------------------|---------|-------------|
+| `enabled`         | `true`  | When `false`, all writes use the regular ActiveRecord path. |
+| `batch_window_ms` | `50`    | Maximum latency added to a write while the worker collects a batch. |
+| `max_batch_size`  | `500`   | Upper bound of statements flushed in one pipeline. |
+| `wait_timeout`    | `nil`   | Raises `ActivePipeline::TimeoutError` in the caller after this many seconds. The statement is **not** cancelled and may still commit afterwards. |
+
+## Transactions and tradeoffs
+
+Pipelined statements run on the worker's connections, not on the connection of the calling
+thread. Keep the following in mind:
+
+- **Materialized transactions are respected.** If the current connection already started a
+  transaction (it ran any query inside `transaction do ... end`, including the `SELECT` of a
+  uniqueness validation or a `lock`), the write runs on that connection as usual. This keeps
+  rollbacks and row locks correct and avoids deadlocking against your own transaction.
+- **Lazy transactions are not.** A `transaction` block whose first statement is a write
+  gets that write committed by the pipeline independently. A later `raise
+  ActiveRecord::Rollback` will not undo it. Use `ActivePipeline.bypass` or read something
+  first when several writes must commit atomically.
+- **Connections.** The worker opens one connection per database and table it writes to.
+  Size `max_connections` on the server accordingly.
+- **Ordering.** Statements are applied in queue order within a table. There is no ordering
+  guarantee between different tables in the same batch. A single thread is never affected,
+  because each caller waits for its own statement to finish.
+- **Bulk `insert_all`/`upsert_all`** and raw `execute` calls are not pipelined.
+
+## Instrumentation
+
+Pipelined statements are still logged and instrumented as `sql.active_record`. In addition,
+the worker emits one `batch.active_pipeline` event per flushed group:
+
+```ruby
+ActiveSupport::Notifications.subscribe("batch.active_pipeline") do |event|
+  event.payload # => { table: "users", size: 42, rounds: 2, failed: 1 }
+end
+```
+
+`rounds` is the number of pipelines needed to isolate failures. `failed` is the number of
+statements that were rejected.
+
+## Development
+
+You need a running PostgreSQL. The specs connect using `DB_HOST`, `DB_PORT`, `DB_NAME`,
+`DB_USER` and `DB_PASSWORD`. The defaults are `localhost`, `5432`, `active_pipeline_test`,
+`postgres` and `postgres`.
+
+```sh
+createdb active_pipeline_test
+bundle install
+bundle exec rake # runs the specs
+```
+
+Every run writes a coverage report to `coverage/index.html`. On CI it also produces
+`coverage/lcov.info`, which is uploaded to Coveralls.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/thrashattack/active_pipeline.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b my-feature`)
+3. Add specs for your change and make sure `bundle exec rake` passes
+4. Open a pull request
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).

data/lib/active_pipeline/adapter_extension.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ActivePipeline
+  # Prepended to ActiveRecord::ConnectionAdapters::PostgreSQLAdapter. Diverts
+  # INSERT/UPDATE/DELETE statements to the worker when it is safe to do so and
+  # falls back to the stock implementation otherwise.
+  module AdapterExtension
+    def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil)
+      return super unless pipeline_write? && (use_insert_returning? || pk == false)
+
+      insert_sql, insert_binds = sql_for_insert(sql, pk, binds, returning)
+      pipeline_execute(:insert, insert_sql, name, insert_binds) { super }
+    end
+
+    def exec_update(sql, name = nil, binds = [])
+      return super unless pipeline_write?
+
+      pipeline_execute(:update, sql, name, binds) { super }
+    end
+
+    def exec_delete(sql, name = nil, binds = [])
+      return super unless pipeline_write?
+
+      pipeline_execute(:delete, sql, name, binds) { super }
+    end
+
+    private
+
+    # A materialized transaction means this connection already sent BEGIN (and
+    # may hold row locks), so the statement has to run on this very connection:
+    # pipelining it would escape the transaction or deadlock against it.
+    def pipeline_write?
+      ActivePipeline.enabled &&
+        ActivePipeline.running? &&
+        !ActivePipeline.bypassed? &&
+        !current_transaction.materialized?
+    end
+
+    def pipeline_execute(operation, sql, name, binds)
+      casted_binds = type_casted_binds(binds)
+      payload = Payload.new(operation: operation, sql: sql, binds: casted_binds, db_config: pool.db_config)
+
+      return yield unless ActivePipeline.enqueue(payload)
+
+      log(sql, name, binds, casted_binds) do
+        payload.wait(ActivePipeline.wait_timeout)
+      rescue PG::Error => e
+        raise translate_exception_class(e, sql, binds)
+      end
+    end
+  end
+end

data/lib/active_pipeline/payload.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ActivePipeline
+  # A single write statement waiting in the queue. The caller thread blocks on
+  # +wait+ until the worker resolves it with +fulfill+ or +reject+.
+  class Payload
+    UNKNOWN_TABLE = "unknown"
+
+    IDENTIFIER = /(?:"(?:[^"]|"")+"|[\w$]+)/
+    TABLE_REGEX = %r{
+      \A\s*(?:/\*.*?\*/\s*)*                  # leading query-log comments
+      (?:INSERT\s+INTO|UPDATE|DELETE\s+FROM)\s+
+      (#{IDENTIFIER}(?:\.#{IDENTIFIER})?)       # optionally schema-qualified
+    }mix
+
+    attr_reader :operation, :sql, :binds, :db_config, :table_name
+
+    def self.table_name_for(sql)
+      match = TABLE_REGEX.match(sql)
+      match && match[1].delete('"')
+    end
+
+    def initialize(operation:, sql:, binds:, db_config:)
+      @operation = operation
+      @sql = sql
+      @binds = binds
+      @db_config = db_config
+      @table_name = self.class.table_name_for(sql) || UNKNOWN_TABLE
+      @ivar = Concurrent::IVar.new
+    end
+
+    def group_key
+      [db_config, table_name]
+    end
+
+    def fulfill(value)
+      @ivar.set(value) unless @ivar.complete?
+    end
+
+    def reject(error)
+      @ivar.fail(error) unless @ivar.complete?
+    end
+
+    def resolved?
+      @ivar.complete?
+    end
+
+    def wait(timeout = nil)
+      value = @ivar.value!(timeout)
+      raise TimeoutError, "statement was not resolved within #{timeout}s" unless @ivar.complete?
+
+      value
+    end
+  end
+end

data/lib/active_pipeline/version.rb

@@ -0,0 +1,3 @@
+module ActivePipeline
+  VERSION = "0.1.0"
+end

data/lib/active_pipeline/worker.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module ActivePipeline
+  # Background thread that drains the queue, groups statements per
+  # (database, table) and flushes each group through a dedicated connection in
+  # PostgreSQL pipeline mode.
+  #
+  # Every group runs as one implicit transaction: when a statement fails the
+  # server rolls the whole group back, the failing statement is rejected and
+  # the remaining ones are pipelined again.
+  class Worker
+    ABORTED = Object.new.freeze
+    private_constant :ABORTED
+
+    def initialize
+      @queue = ::Queue.new
+      @adapters = Concurrent::Map.new
+      @thread = nil
+      @pid = nil
+    end
+
+    def start!
+      return if @thread
+
+      @pid = Process.pid
+      @thread = Thread.new { run_loop }
+      @thread.name = "active_pipeline"
+    end
+
+    # Closes the queue, lets the thread drain whatever is already queued and
+    # releases the connections.
+    def stop!
+      # A forked child has no worker thread and shares the parent's sockets:
+      # closing them would kill the parent's sessions, so it is left untouched.
+      return if @thread.nil? || forked?
+
+      @queue.close
+      join_thread
+      reject_leftovers(Error.new("ActivePipeline worker stopped"))
+    end
+
+    def running?
+      !@queue.closed? && !forked? && !!@thread&.alive?
+    end
+
+    def enqueue(payload)
+      return false unless running?
+
+      @queue.push(payload)
+      true
+    rescue ClosedQueueError
+      false
+    end
+
+    private
+
+    # Thread#join re-raises a crash that the thread already reported.
+    def join_thread
+      @thread.join
+    rescue StandardError
+      nil
+    end
+
+    def forked?
+      @pid != Process.pid
+    end
+
+    def run_loop
+      while (first = @queue.pop)
+        batch = [first]
+        collect_batch(batch)
+        process_batch(batch)
+      end
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      # The thread is dying: release every caller instead of leaving it parked.
+      # running? turns false, so later writes fall back to regular ActiveRecord.
+      batch&.each { |payload| payload.reject(e) }
+      reject_leftovers(e)
+      raise
+    ensure
+      disconnect_all
+    end
+
+    def collect_batch(batch)
+      deadline = monotonic_now + (ActivePipeline.batch_window_ms / 1000.0)
+
+      while batch.size < ActivePipeline.max_batch_size
+        remaining = deadline - monotonic_now
+        break if remaining <= 0
+
+        payload = @queue.pop(timeout: remaining)
+        break unless payload
+
+        batch << payload
+      end
+    end
+
+    def process_batch(batch)
+      futures = batch.group_by(&:group_key).map do |key, items|
+        Concurrent::Promises.future(key, items) { |k, i| process_group(k, i) }
+      end
+      futures.each(&:wait)
+    ensure
+      batch.each { |payload| payload.reject(Error.new("statement was not processed")) }
+    end
+
+    def process_group(key, items)
+      resolutions = {}.compare_by_identity
+
+      ActiveSupport::Notifications.instrument(BATCH_EVENT, table: key.last, size: items.size) do |event|
+        run_isolated(key, items, resolutions, event)
+      end
+    rescue StandardError => e
+      discard_adapter(key)
+      items.each { |item| resolutions[item] ||= [:reject, e] }
+    ensure
+      # Resolve only after the instrumentation finished so subscribers always
+      # observe the batch before the callers wake up.
+      resolutions.each { |item, (action, value)| item.public_send(action, value) }
+    end
+
+    def run_isolated(key, items, resolutions, event)
+      pending = items.dup
+      rounds = 0
+      failed = 0
+
+      until pending.empty?
+        rounds += 1
+        results = execute_pipeline(raw_connection_for(key), pending)
+        index = results.index { |result| result.is_a?(Exception) }
+
+        if index
+          failed += 1
+          resolutions[pending.delete_at(index)] = [:reject, results[index]]
+        elsif results.any?(ABORTED)
+          raise Error, "pipeline aborted without reporting an error"
+        else
+          pending.zip(results) { |item, result| resolutions[item] = [:fulfill, result] }
+          pending = []
+        end
+      end
+    ensure
+      event[:rounds] = rounds
+      event[:failed] = failed
+    end
+
+    def execute_pipeline(conn, items)
+      conn.enter_pipeline_mode
+      items.each { |item| conn.send_query_params(item.sql, item.binds) }
+      conn.pipeline_sync
+
+      results = items.map { |item| convert(read_result(conn), item) }
+      read_sync(conn)
+      conn.exit_pipeline_mode
+      results
+    end
+
+    # In pipeline mode each statement's results are terminated by a nil.
+    def read_result(conn)
+      last = nil
+      while (result = conn.get_result)
+        last = result
+      end
+      last
+    end
+
+    def convert(result, item)
+      case result&.result_status
+      when PG::PGRES_TUPLES_OK, PG::PGRES_COMMAND_OK
+        value = item.operation == :insert ? ActiveRecord::Result.new(result.fields, result.values) : result.cmd_tuples
+        result.clear
+        value
+      when PG::PGRES_PIPELINE_ABORTED
+        ABORTED
+      when PG::PGRES_FATAL_ERROR
+        error_for(result)
+      else
+        raise Error, "unexpected result status #{result&.result_status.inspect} for #{item.sql}"
+      end
+    end
+
+    # PG::Result#check raises the specific PG::Error subclass (UniqueViolation,
+    # NotNullViolation...) with the result attached, which is what ActiveRecord
+    # needs to translate it into RecordNotUnique, NotNullViolation, etc.
+    def error_for(result)
+      result.check
+      Error.new("statement failed without an error message")
+    rescue PG::Error => e
+      e
+    end
+
+    # The implicit transaction commits at the sync point. An error there (e.g. a
+    # deferred constraint) can't be attributed to a statement, so it is raised
+    # and rejects the whole group.
+    def read_sync(conn)
+      result = conn.get_result
+      return if result&.result_status == PG::PGRES_PIPELINE_SYNC
+
+      result&.check
+      raise Error, "pipeline sync was not acknowledged"
+    end
+
+    # Each group gets its own ActiveRecord adapter so the session is configured
+    # exactly like the application's (search_path, timezone, variables...).
+    def raw_connection_for(key)
+      adapter = @adapters.compute_if_absent(key) do
+        ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.new(key.first.configuration_hash)
+      end
+      adapter.raw_connection
+    end
+
+    def discard_adapter(key)
+      adapter = @adapters.delete(key)
+      adapter&.disconnect!
+    rescue StandardError
+      nil
+    end
+
+    def disconnect_all
+      @adapters.each_key { |key| discard_adapter(key) }
+    end
+
+    def reject_leftovers(error)
+      while (payload = @queue.pop(timeout: 0))
+        payload.reject(error)
+      end
+    end
+
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/active_pipeline.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "concurrent"
+require "active_record"
+require "pg"
+
+require_relative "active_pipeline/version"
+require_relative "active_pipeline/payload"
+require_relative "active_pipeline/worker"
+require_relative "active_pipeline/adapter_extension"
+
+module ActivePipeline
+  class Error < StandardError; end
+
+  # Raised in the caller thread when +wait_timeout+ elapses before the worker
+  # resolved the statement. The statement may still be committed afterwards.
+  class TimeoutError < Error; end
+
+  # ActiveSupport::Notifications event emitted once per (database, table) group
+  # flushed by the worker. Payload: :table, :size, :rounds, :failed.
+  BATCH_EVENT = "batch.active_pipeline"
+
+  @mutex = Mutex.new
+
+  class << self
+    # Master switch. When false every write goes straight through ActiveRecord.
+    attr_accessor :enabled
+
+    # How long the worker keeps collecting statements after the first one arrives.
+    attr_accessor :batch_window_ms
+
+    # Upper bound of statements flushed in a single pipeline.
+    attr_accessor :max_batch_size
+
+    # Seconds a caller waits for its statement to be resolved (nil waits forever).
+    attr_accessor :wait_timeout
+
+    def configure
+      yield self
+    end
+
+    def start!
+      @mutex.synchronize do
+        @worker = Worker.new.tap(&:start!) unless @worker&.running?
+      end
+    end
+
+    def stop!
+      @mutex.synchronize do
+        @worker&.stop!
+        @worker = nil
+      end
+    end
+
+    def running?
+      !!@worker&.running?
+    end
+
+    # Runs the block with the pipeline disabled for the current thread/fiber.
+    def bypass
+      previous = Thread.current[:active_pipeline_bypass]
+      Thread.current[:active_pipeline_bypass] = true
+      yield
+    ensure
+      Thread.current[:active_pipeline_bypass] = previous
+    end
+
+    def bypassed?
+      !!Thread.current[:active_pipeline_bypass]
+    end
+
+    # Hands a payload to the running worker. Returns false when nothing is
+    # running so the caller can fall back to a regular, synchronous write.
+    def enqueue(payload) # :nodoc:
+      !!@worker&.enqueue(payload)
+    end
+  end
+
+  self.enabled = true
+  self.batch_window_ms = 50
+  self.max_batch_size = 500
+  self.wait_timeout = nil
+end
+
+ActiveSupport.on_load(:active_record_postgresqladapter) do
+  prepend ActivePipeline::AdapterExtension
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: active_pipeline
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Carlos (Thrashattack) Cunha
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Implements Go-channel-like write batching for Rails and Sidekiq using
+  PostgreSQL pipeline mode, with per-statement error isolation.
+email:
+- henrique2092@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/active_pipeline.rb
+- lib/active_pipeline/adapter_extension.rb
+- lib/active_pipeline/payload.rb
+- lib/active_pipeline/version.rb
+- lib/active_pipeline/worker.rb
+homepage: https://github.com/thrashattack/active_pipeline
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/thrashattack/active_pipeline
+  source_code_uri: https://github.com/thrashattack/active_pipeline
+  changelog_uri: https://github.com/thrashattack/active_pipeline/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/thrashattack/active_pipeline/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Transparent PostgreSQL pipeline batching for ActiveRecord.
+test_files: []