cdc-concurrent 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a8f1b6796df6daf32144dc7df7206777863c4d693997e3b83e500d0c360ff699
+  data.tar.gz: eabe19f74600193950154f4921203123b78bd1c2db8a2ca576bf74c83ab1eb5b
+SHA512:
+  metadata.gz: eabccfa38225330187c12f4c681c68f973126e60910c00402cc274a400e776753e46b1a5605692b363f8d064971cb26253ab72d305b69d9e2106e49733c964d7
+  data.tar.gz: 2210868f800f9ae0cddf5cf24bf6104be5dfd9f74d2b74694f66571cdd87031ba714ba2b12356c4401b71e4dcad901187848ad1f8a8746f7e0b2f236122dec9c

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-05-31
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Kenneth C. Demanawa
+
+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,119 @@
+# cdc-concurrent
+
+Optional I/O-concurrent runtime adapter for `cdc-core`.
+
+`cdc-concurrent` executes `CDC::Core::Processor` objects with Fiber-scheduler-based I/O concurrency using `async`. It is the I/O-bound twin of `cdc-parallel`.
+
+## Requirements
+
+- Ruby 3.4+
+- `cdc-core`
+- `async`
+
+## Purpose
+
+```text
+cdc-core
+   |
+   |-- cdc-parallel
+   |      CPU-bound parallelism
+   |
+   `-- cdc-concurrent
+          I/O-bound concurrency
+```
+
+Use `cdc-concurrent` for processors that spend most of their time waiting on fiber-scheduler-compatible I/O:
+
+- HTTP webhooks
+- external API enrichment
+- Redis publishing
+- OpenSearch or Elasticsearch indexing
+- S3 or object-storage writes
+- async sink fanout
+- database writes through compatible drivers
+
+Use `cdc-parallel` for CPU-bound work such as pgoutput parsing, OID decoding, JSON parsing, diff computation, compression, and analytics calculations.
+
+## Installation
+
+```ruby
+gem "cdc-concurrent"
+```
+
+## Usage
+
+```ruby
+require "cdc/core"
+require "cdc/concurrent"
+
+class WebhookProcessor < CDC::Core::Processor
+  concurrent_safe!
+
+  def process(event)
+    # Perform fiber-scheduler-compatible I/O here.
+    CDC::Core::ProcessorResult.success(event)
+  end
+end
+
+runtime = CDC::Concurrent::Runtime.new(
+  processor: WebhookProcessor.new,
+  concurrency: 100,
+  timeout: 5.0
+)
+
+result = runtime.process(event)
+runtime.shutdown
+```
+
+## Batch Processing
+
+```ruby
+results = runtime.process_many(events)
+```
+
+Results preserve input order by default. Set `preserve_order: false` when completion order is acceptable.
+
+## Transaction Processing
+
+```ruby
+result = runtime.process_transaction(transaction)
+```
+
+Transactions are processed event-by-event. The returned `ProcessorResult#event` contains the per-event results. If any event fails, the transaction result fails and carries the first error.
+
+## Processor Safety
+
+Only processors that declare `concurrent_safe!` can run in this runtime.
+
+```ruby
+class SinkProcessor < CDC::Core::Processor
+  concurrent_safe!
+end
+```
+
+Unsafe processors raise:
+
+```ruby
+CDC::Concurrent::UnsafeProcessorError
+```
+
+A concurrent-safe processor should avoid unsafe shared mutable instance state. This runtime runs tasks concurrently in one Ruby process; it does not isolate mutable objects like Ractors do.
+
+## Important Limits
+
+`cdc-concurrent` improves throughput only for I/O that cooperates with Ruby's Fiber scheduler. Blocking libraries that do not yield to the scheduler will still block the process.
+
+For CPU-bound processing, use `cdc-parallel`.
+
+## Roadmap
+
+- Move `concurrent_safe!` into `cdc-core`
+- Retry and backoff policies
+- Dead-letter handling
+- Async HTTP webhook helpers
+- Sink abstractions
+- Async Redis/OpenSearch integrations
+
+## License
+
+MIT.

data/lib/cdc/concurrent/configuration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module CDC
+  module Concurrent
+    # Immutable configuration for concurrent runtimes.
+    Configuration = Data.define(:concurrency, :timeout, :preserve_order) do
+      # @param concurrency [Integer] maximum concurrent tasks.
+      # @param timeout [Float, nil] optional timeout.
+      # @param preserve_order [Boolean] whether batch results preserve input order.
+      def initialize(concurrency: 100, timeout: nil, preserve_order: true)
+        raise ArgumentError, "concurrency must be an Integer" unless concurrency.is_a?(Integer)
+        raise ArgumentError, "concurrency must be greater than zero" unless concurrency.positive?
+
+        super
+        freeze
+      end
+    end
+  end
+end

data/lib/cdc/concurrent/errors.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module CDC
+  module Concurrent
+    # Base cdc-concurrent error.
+    class Error < StandardError; end
+
+    # Raised when a processor has not declared itself concurrent-safe.
+    class UnsafeProcessorError < Error; end
+
+    # Raised when work is submitted after shutdown.
+    class ShutdownError < Error; end
+
+    # Raised when the runtime receives an unsupported work item.
+    class UnsupportedWorkItemError < Error; end
+
+    # Raised when processing exceeds the configured timeout.
+    class TimeoutError < Error; end
+  end
+end

data/lib/cdc/concurrent/processor_extensions.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module CDC
+  # Optional concurrent runtime adapter for cdc-core processors.
+  module Concurrent
+    # Adds concurrent-safe declarations to CDC::Core::Processor subclasses.
+    module ProcessorExtensions
+      # Class methods added to CDC::Core::Processor.
+      module ClassMethods
+        # Declare this processor safe for concurrent execution.
+        def concurrent_safe!
+          @concurrent_safe = true
+        end
+
+        # @return [Boolean] whether instances are concurrent-safe.
+        def concurrent_safe?
+          @concurrent_safe == true
+        end
+      end
+
+      # @return [Boolean] whether this processor instance is concurrent-safe.
+      def concurrent_safe?
+        self.class.respond_to?(:concurrent_safe?) && self.class.concurrent_safe?
+      end
+    end
+
+    # Installs concurrent-safe declarations on CDC::Core::Processor.
+    #
+    # @return [void]
+    def self.install_processor_extensions!
+      CDC::Core::Processor.extend(ProcessorExtensions::ClassMethods)
+      CDC::Core::Processor.include(ProcessorExtensions)
+    end
+  end
+end
+
+CDC::Concurrent.install_processor_extensions!

data/lib/cdc/concurrent/processor_pool.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module CDC
+  module Concurrent
+    # Executes one concurrent-safe processor using Async tasks.
+    class ProcessorPool
+      # @param processor [CDC::Core::Processor]
+      # @param concurrency [Integer]
+      # @param timeout [Float, nil]
+      # @param preserve_order [Boolean]
+      def initialize(processor:, concurrency: 100, timeout: nil, preserve_order: true)
+        validate_processor!(processor)
+
+        @processor = processor
+        @configuration = Configuration.new(concurrency:, timeout:, preserve_order:)
+        @shutdown = false
+      end
+
+      # @param event [CDC::Core::ChangeEvent]
+      # @return [CDC::Core::ProcessorResult]
+      def process(event)
+        raise ShutdownError, "processor pool has been shut down" if @shutdown
+
+        process_one(event)
+      end
+
+      # @param events [Array<CDC::Core::ChangeEvent>]
+      # @return [Array<CDC::Core::ProcessorResult>]
+      def process_many(events)
+        raise ShutdownError, "processor pool has been shut down" if @shutdown
+        return [].freeze if events.empty?
+
+        indexed_results = []
+
+        process_batch(events, indexed_results)
+
+        indexed_results.sort_by!(&:first) if @configuration.preserve_order
+        indexed_results.map(&:last).freeze
+      end
+
+      # @return [void]
+      def shutdown
+        @shutdown = true
+      end
+
+      private
+
+      def validate_processor!(processor)
+        return if processor.respond_to?(:concurrent_safe?) && processor.concurrent_safe?
+
+        raise UnsafeProcessorError, "#{processor.class} must declare concurrent_safe!"
+      end
+
+      def process_batch(events, indexed_results)
+        Async do |task|
+          semaphore = Async::Semaphore.new(@configuration.concurrency, parent: task)
+
+          events.each_with_index do |event, index|
+            semaphore.async do |subtask|
+              indexed_results << [index, process_with_task(subtask, event)]
+            end
+          end
+        end.wait
+      end
+
+      def process_one(event)
+        result = nil
+
+        Async do |task|
+          result = process_with_task(task, event)
+        end.wait
+
+        result
+      rescue StandardError => e
+        ResultCollector.failure(e)
+      end
+
+      def process_with_task(task, event)
+        ResultCollector.normalize(call_processor(task, event))
+      rescue Async::TimeoutError => e
+        ResultCollector.failure(TimeoutError.new(e.message))
+      rescue StandardError => e
+        ResultCollector.failure(e)
+      end
+
+      def call_processor(task, event)
+        return @processor.process(event) unless @configuration.timeout
+
+        task.with_timeout(@configuration.timeout) { @processor.process(event) }
+      end
+    end
+  end
+end

data/lib/cdc/concurrent/result_collector.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module CDC
+  module Concurrent
+    # Normalizes values returned by concurrent workers.
+    class ResultCollector
+      # @param value [Object]
+      # @return [CDC::Core::ProcessorResult]
+      def self.normalize(value)
+        return value if value.is_a?(CDC::Core::ProcessorResult)
+
+        CDC::Core::ProcessorResult.success(value)
+      rescue StandardError => e
+        failure(e)
+      end
+
+      # @param error [Exception]
+      # @return [CDC::Core::ProcessorResult]
+      def self.failure(error)
+        CDC::Core::ProcessorResult.failure(error)
+      end
+    end
+  end
+end

data/lib/cdc/concurrent/router.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module CDC
+  module Concurrent
+    # Routes CDC work items to the correct concurrent pool.
+    class Router
+      # @param processor_pool [ProcessorPool]
+      # @param transaction_pool [TransactionPool]
+      def initialize(processor_pool:, transaction_pool:)
+        @processor_pool = processor_pool
+        @transaction_pool = transaction_pool
+      end
+
+      # @param item [Object]
+      # @return [Object]
+      def process(item)
+        case item
+        when CDC::Core::ChangeEvent
+          @processor_pool.process(item)
+        when CDC::Core::TransactionEnvelope
+          @transaction_pool.process(item)
+        when Array
+          @processor_pool.process_many(item)
+        else
+          raise UnsupportedWorkItemError, "unsupported CDC work item: #{item.class}"
+        end
+      end
+    end
+  end
+end

data/lib/cdc/concurrent/runtime.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module CDC
+  module Concurrent
+    # High-level concurrent runtime facade for cdc-core processors.
+    class Runtime
+      # @param processor [CDC::Core::Processor]
+      # @param concurrency [Integer]
+      # @param timeout [Float, nil]
+      # @param preserve_order [Boolean]
+      def initialize(processor:, concurrency: 100, timeout: nil, preserve_order: true)
+        @processor_pool = ProcessorPool.new(processor:, concurrency:, timeout:, preserve_order:)
+        @transaction_pool = TransactionPool.new(processor:, concurrency:, timeout:, preserve_order:)
+        @router = Router.new(processor_pool: @processor_pool, transaction_pool: @transaction_pool)
+        @shutdown = false
+      end
+
+      # @param item [Object]
+      # @return [Object]
+      def process(item)
+        raise ShutdownError, "runtime has been shut down" if @shutdown
+
+        @router.process(item)
+      end
+
+      # @param events [Array<CDC::Core::ChangeEvent>]
+      # @return [Array<CDC::Core::ProcessorResult>]
+      def process_many(events)
+        process(events)
+      end
+
+      # @param transaction [CDC::Core::TransactionEnvelope]
+      # @return [CDC::Core::ProcessorResult]
+      def process_transaction(transaction)
+        process(transaction)
+      end
+
+      # @return [void]
+      def shutdown
+        return if @shutdown
+
+        @shutdown = true
+        @processor_pool.shutdown
+        @transaction_pool.shutdown
+      end
+    end
+  end
+end

data/lib/cdc/concurrent/transaction_pool.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module CDC
+  module Concurrent
+    # Processes TransactionEnvelope events as a single ordering-preserving unit.
+    class TransactionPool
+      # @param processor [CDC::Core::Processor]
+      # @param concurrency [Integer]
+      # @param timeout [Float, nil]
+      # @param preserve_order [Boolean]
+      def initialize(processor:, concurrency: 100, timeout: nil, preserve_order: true)
+        @processor_pool = ProcessorPool.new(processor:, concurrency:, timeout:, preserve_order:)
+      end
+
+      # @param transaction [CDC::Core::TransactionEnvelope]
+      # @return [CDC::Core::ProcessorResult]
+      def process(transaction)
+        results = @processor_pool.process_many(transaction.events).freeze
+        failure = results.find(&:failure?)
+
+        return CDC::Core::ProcessorResult.failure(failure.error, event: results) if failure
+
+        CDC::Core::ProcessorResult.success(results)
+      end
+
+      # @return [void]
+      def shutdown
+        @processor_pool.shutdown
+      end
+    end
+  end
+end

data/lib/cdc/concurrent/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module CDC
+  module Concurrent
+    # Current cdc-concurrent version.
+    VERSION = "0.0.0"
+  end
+end

data/lib/cdc/concurrent.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "async"
+require "async/semaphore"
+require "cdc/core"
+
+require_relative "concurrent/version"
+require_relative "concurrent/errors"
+require_relative "concurrent/configuration"
+require_relative "concurrent/processor_extensions"
+require_relative "concurrent/result_collector"
+require_relative "concurrent/processor_pool"
+require_relative "concurrent/transaction_pool"
+require_relative "concurrent/router"
+require_relative "concurrent/runtime"
+
+module CDC
+  # Optional concurrent runtime adapter for cdc-core processors.
+  module Concurrent
+  end
+end

data/lib/cdc_concurrent.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "cdc/concurrent"

data/sig/cdc/concurrent/configuration.rbs

@@ -0,0 +1,6 @@
+module CDC
+  module Concurrent
+    # Immutable configuration for concurrent runtimes.
+    Configuration: untyped
+  end
+end

data/sig/cdc/concurrent/errors.rbs

@@ -0,0 +1,23 @@
+module CDC
+  module Concurrent
+    # Base cdc-concurrent error.
+    class Error < StandardError
+    end
+
+    # Raised when a processor has not declared itself concurrent-safe.
+    class UnsafeProcessorError < Error
+    end
+
+    # Raised when work is submitted after shutdown.
+    class ShutdownError < Error
+    end
+
+    # Raised when the runtime receives an unsupported work item.
+    class UnsupportedWorkItemError < Error
+    end
+
+    # Raised when processing exceeds the configured timeout.
+    class TimeoutError < Error
+    end
+  end
+end

data/sig/cdc/concurrent/processor_extensions.rbs

@@ -0,0 +1,26 @@
+module CDC
+  # Optional concurrent runtime adapter for cdc-core processors.
+  module Concurrent
+    # Adds concurrent-safe declarations to CDC::Core::Processor subclasses.
+    module ProcessorExtensions
+      # Class methods added to CDC::Core::Processor.
+      module ClassMethods
+        @concurrent_safe: untyped
+
+        # Declare this processor safe for concurrent execution.
+        def concurrent_safe!: () -> untyped
+
+        # @return [Boolean] whether instances are concurrent-safe.
+        def concurrent_safe?: () -> untyped
+      end
+
+      # @return [Boolean] whether this processor instance is concurrent-safe.
+      def concurrent_safe?: () -> untyped
+    end
+
+    # Installs concurrent-safe declarations on CDC::Core::Processor.
+    #
+    # @return [void]
+    def self.install_processor_extensions!: () -> untyped
+  end
+end

data/sig/cdc/concurrent/processor_pool.rbs

@@ -0,0 +1,41 @@
+module CDC
+  module Concurrent
+    # Executes one concurrent-safe processor using Async tasks.
+    class ProcessorPool
+      @processor: untyped
+
+      @configuration: untyped
+
+      @shutdown: untyped
+
+      # @param processor [CDC::Core::Processor]
+      # @param concurrency [Integer]
+      # @param timeout [Float, nil]
+      # @param preserve_order [Boolean]
+      def initialize: (processor: untyped, ?concurrency: ::Integer, ?timeout: untyped?, ?preserve_order: bool) -> void
+
+      # @param event [CDC::Core::ChangeEvent]
+      # @return [CDC::Core::ProcessorResult]
+      def process: (untyped event) -> untyped
+
+      # @param events [Array<CDC::Core::ChangeEvent>]
+      # @return [Array<CDC::Core::ProcessorResult>]
+      def process_many: (untyped events) -> (::Array[untyped] | untyped)
+
+      # @return [void]
+      def shutdown: () -> untyped
+
+      private
+
+      def validate_processor!: (untyped processor) -> (nil | untyped)
+
+      def process_batch: (untyped events, untyped indexed_results) -> untyped
+
+      def process_one: (untyped event) -> untyped
+
+      def process_with_task: (untyped task, untyped event) -> untyped
+
+      def call_processor: (untyped task, untyped event) -> untyped
+    end
+  end
+end

data/sig/cdc/concurrent/result_collector.rbs

@@ -0,0 +1,14 @@
+module CDC
+  module Concurrent
+    # Normalizes values returned by concurrent workers.
+    class ResultCollector
+      # @param value [Object]
+      # @return [CDC::Core::ProcessorResult]
+      def self.normalize: (untyped value) -> untyped
+
+      # @param error [Exception]
+      # @return [CDC::Core::ProcessorResult]
+      def self.failure: (untyped error) -> untyped
+    end
+  end
+end

data/sig/cdc/concurrent/router.rbs

@@ -0,0 +1,18 @@
+module CDC
+  module Concurrent
+    # Routes CDC work items to the correct concurrent pool.
+    class Router
+      @processor_pool: untyped
+
+      @transaction_pool: untyped
+
+      # @param processor_pool [ProcessorPool]
+      # @param transaction_pool [TransactionPool]
+      def initialize: (processor_pool: untyped, transaction_pool: untyped) -> void
+
+      # @param item [Object]
+      # @return [Object]
+      def process: (untyped item) -> untyped
+    end
+  end
+end

data/sig/cdc/concurrent/runtime.rbs

@@ -0,0 +1,35 @@
+module CDC
+  module Concurrent
+    # High-level concurrent runtime facade for cdc-core processors.
+    class Runtime
+      @processor_pool: untyped
+
+      @transaction_pool: untyped
+
+      @router: untyped
+
+      @shutdown: untyped
+
+      # @param processor [CDC::Core::Processor]
+      # @param concurrency [Integer]
+      # @param timeout [Float, nil]
+      # @param preserve_order [Boolean]
+      def initialize: (processor: untyped, ?concurrency: ::Integer, ?timeout: untyped?, ?preserve_order: bool) -> void
+
+      # @param item [Object]
+      # @return [Object]
+      def process: (untyped item) -> untyped
+
+      # @param events [Array<CDC::Core::ChangeEvent>]
+      # @return [Array<CDC::Core::ProcessorResult>]
+      def process_many: (untyped events) -> untyped
+
+      # @param transaction [CDC::Core::TransactionEnvelope]
+      # @return [CDC::Core::ProcessorResult]
+      def process_transaction: (untyped transaction) -> untyped
+
+      # @return [void]
+      def shutdown: () -> (nil | untyped)
+    end
+  end
+end

data/sig/cdc/concurrent/transaction_pool.rbs

@@ -0,0 +1,21 @@
+module CDC
+  module Concurrent
+    # Processes TransactionEnvelope events as a single ordering-preserving unit.
+    class TransactionPool
+      @processor_pool: untyped
+
+      # @param processor [CDC::Core::Processor]
+      # @param concurrency [Integer]
+      # @param timeout [Float, nil]
+      # @param preserve_order [Boolean]
+      def initialize: (processor: untyped, ?concurrency: ::Integer, ?timeout: untyped?, ?preserve_order: bool) -> void
+
+      # @param transaction [CDC::Core::TransactionEnvelope]
+      # @return [CDC::Core::ProcessorResult]
+      def process: (untyped transaction) -> untyped
+
+      # @return [void]
+      def shutdown: () -> untyped
+    end
+  end
+end

data/sig/cdc/concurrent/version.rbs

@@ -0,0 +1,6 @@
+module CDC
+  module Concurrent
+    # Current cdc-concurrent version.
+    VERSION: "0.1.0"
+  end
+end

data/sig/cdc/concurrent.rbs

@@ -0,0 +1,5 @@
+module CDC
+  # Optional concurrent runtime adapter for cdc-core processors.
+  module Concurrent
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: cdc-concurrent
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Ken C. Demanawa
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: cdc-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: |
+  cdc-concurrent provides optional Async-backed I/O-concurrent execution for
+  cdc-core. It accelerates I/O-bound PostgreSQL Change Data Capture (CDC)
+  event processing while preserving the cdc-core programming model.
+email:
+- kenneth.c.demanawa@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/cdc/concurrent.rb
+- lib/cdc/concurrent/configuration.rb
+- lib/cdc/concurrent/errors.rb
+- lib/cdc/concurrent/processor_extensions.rb
+- lib/cdc/concurrent/processor_pool.rb
+- lib/cdc/concurrent/result_collector.rb
+- lib/cdc/concurrent/router.rb
+- lib/cdc/concurrent/runtime.rb
+- lib/cdc/concurrent/transaction_pool.rb
+- lib/cdc/concurrent/version.rb
+- lib/cdc_concurrent.rb
+- sig/cdc/concurrent.rbs
+- sig/cdc/concurrent/configuration.rbs
+- sig/cdc/concurrent/errors.rbs
+- sig/cdc/concurrent/processor_extensions.rbs
+- sig/cdc/concurrent/processor_pool.rbs
+- sig/cdc/concurrent/result_collector.rbs
+- sig/cdc/concurrent/router.rbs
+- sig/cdc/concurrent/runtime.rbs
+- sig/cdc/concurrent/transaction_pool.rbs
+- sig/cdc/concurrent/version.rbs
+- sig/cdc_concurrent.rbs
+homepage: https://kanutocd.github.io/cdc-concurrent
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://kanutocd.github.io/cdc-concurrent
+  documentation_uri: https://kanutocd.github.io/cdc-concurrent
+  source_code_uri: https://github.com/kanutocd/cdc-concurrent
+  changelog_uri: https://github.com/kanutocd/cdc-concurrent/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Optional I/O-concurrent Change Data Capture (CDC) runtime for cdc-core.
+test_files: []