listenable 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a40496b36e34ee9be039eafd3ca5ce235d7fff2c2ccd93dfb1041bd75fa5b87f
-  data.tar.gz: 89505e376d1f337dd5e9d7172383a07501846613fcf556fa94682383b2a42d85
+  metadata.gz: a8ebfdc90196162ce2a340f960b6c7f0f1de287c4806cf230bded917eee5bd3f
+  data.tar.gz: 8435bcb681df67ae94a66225e5f95765145cb81dfbed4b4f02362682fceadff4
 SHA512:
-  metadata.gz: 7b2a55fee58e33e6f9f3fe1354d67a86668c93294e9e94274fba575ebe415805952f5e53179bf0fd041d00ab361e4c01b07390df3ac4a1f1eebd82eddf50505b
-  data.tar.gz: ef07a946e9bfc66eb038d09b765977cf44e766e2209295d2427bb7f3ad24e35d9827a3c473905d2baecb10f28814e344600ba857650e453c976622604f65074b
+  metadata.gz: 80f93245b2d340672b0c9178f637f3a127230a4348e08b3099f27d2ff43cdd9b8baa77cdf6bf8492ef446c5e55666c3f2b4a16e1b073b1ac33bdd7439f5f1491
+  data.tar.gz: 69681153c86034c8a4c8563478cf6c580b97409566bc50d87537c477106d040fa6837e29b578a0b39ae37f23dbf90a9f4fdab23d7a743a4153afb65f59ee46e4

data/lib/listenable/concern.rb

@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 
 module Listenable
+  extend ActiveSupport::Concern
+
   CALLBACK_MAP = {
     'created' => :after_create,
     'updated' => :after_update,
     'deleted' => :after_destroy
   }.freeze
 
-  def self.included(base)
-    base.extend(ClassMethods)
+  included do
+    # Register this class when Listenable is included
+    Listenable.register_listener(self)
   end
 
-  module ClassMethods
+  class_methods do
     def listen(*hooks, async: false)
       @pending_hooks ||= []
 

data/lib/listenable/railtie.rb

@@ -2,6 +2,12 @@
 
 module Listenable
   class Railtie < Rails::Railtie
+    AFTER_COMMIT_MAP = {
+      'created'  => :create,
+      'updated'  => :update,
+      'destroyed' => :destroy
+    }.freeze
+
     # Cleanup on Rails reload to prevent memory leaks
     config.to_prepare do
       Listenable.cleanup!
@@ -17,57 +23,72 @@ module Listenable
     initializer 'listenable.load' do
       Rails.application.config.to_prepare do
         # Load all listeners (recursive, supports namespaced)
-        listener_files = Dir[Rails.root.join('app/listeners/**/*.rb')]
-        listener_files.each { |f| require_dependency f }
+        Dir[Rails.root.join('app/listeners/**/*.rb')].each do |file|
+          require_dependency file
+        end
 
-        # Find all listener classes
-        listener_classes = ObjectSpace.each_object(Class).select { |klass| klass < Listenable }
-        listener_classes.each do |listener_class|
+        Listenable.listener_classes.each do |listener_class|
           model_class_name = listener_class.name.sub('Listener', '')
           model_class      = model_class_name.safe_constantize
           next unless model_class
 
+          injected_events =
+            model_class.instance_variable_get(:@_listenable_injected_events) || []
+
           listener_class.pending_hooks.each do |hook_info|
             hook     = hook_info[:name]
             async    = hook_info[:async]
             action   = hook.sub('on_', '')
-            callback = Listenable::CALLBACK_MAP[action] or next
             method   = "on_#{action}"
             event    = "#{model_class_name.underscore}.#{action}"
 
-            # unsubscribe old subscribers
-            ActiveSupport::Notifications.notifier.listeners_for(event).each do |subscriber|
-              ActiveSupport::Notifications.unsubscribe(subscriber)
-            end
+            next unless listener_class.respond_to?(method)
 
-            injected_events = model_class.instance_variable_get(:@_listenable_injected_events) || []
+            # Inject callback once per model
             unless injected_events.include?(event)
-              model_class.send(callback) do
+              commit_action = AFTER_COMMIT_MAP[action]
+              next unless commit_action
+
+              model_class.after_commit(on: commit_action) do
                 next unless Listenable.enabled
 
-                ActiveSupport::Notifications.instrument(event, record: self)
+                ActiveSupport::Notifications.instrument(
+                  event,
+                  record_class: self.class,
+                  record_id: id
+                )
               end
+
               injected_events << event
-              model_class.instance_variable_set(:@_listenable_injected_events, injected_events)
+              model_class.instance_variable_set(
+                :@_listenable_injected_events,
+                injected_events
+              )
             end
 
-            next unless listener_class.respond_to?(method)
-
-            # Subscribe and track subscriber for cleanup
+            # Subscribe (only once per reload)
             subscriber = ActiveSupport::Notifications.subscribe(event) do |*args|
               next unless Listenable.enabled
 
               _name, _start, _finish, _id, payload = args
-              record = payload[:record]
 
               if async
-                Railtie.handle_async_listener(listener_class, method, record)
+                Railtie.handle_async_listener(
+                  listener_class,
+                  method,
+                  payload[:record_class],
+                  payload[:record_id]
+                )
               else
-                Railtie.handle_sync_listener(listener_class, method, record)
+                Railtie.handle_sync_listener(
+                  listener_class,
+                  method,
+                  payload[:record_class],
+                  payload[:record_id]
+                )
               end
             end
 
-            # Track subscriber for cleanup on reload
             Listenable.subscribers << subscriber
           end
         end
@@ -75,52 +96,46 @@ module Listenable
     end
 
     class << self
-      # Handle async listener with proper error handling and connection management
-      def handle_async_listener(listener_class, method, record)
-        # Extract minimal data to pass to thread
-        record_id = record.id
-        record_class = record.class
-
-        # Use bounded thread pool to prevent spawning unlimited threads
+      def handle_async_listener(listener_class, method, record_class, record_id)
         Concurrent::Promises.future_on(Listenable.async_executor) do
-          # Wrap in connection pool management to prevent connection exhaustion
           ActiveRecord::Base.connection_pool.with_connection do
             execute_listener(listener_class, method, record_class, record_id)
-          rescue StandardError => e
-            log_error(listener_class, method, e)
           end
-        end.rescue do |e|
+        rescue ActiveRecord::ConnectionTimeoutError => e
           Rails.logger&.error(
-            "[Listenable] Promise failed for #{listener_class}##{method}: #{e.message}"
+            "[Listenable] DB pool exhausted for #{listener_class}##{method}: #{e.message}"
           )
+        rescue StandardError => e
+          log_error(listener_class, method, e)
         end
       end
 
-      # Handle sync listener with proper error handling
-      def handle_sync_listener(listener_class, method, record)
-        listener_class.public_send(method, record)
+      def handle_sync_listener(listener_class, method, record_class, record_id)
+        execute_listener(listener_class, method, record_class, record_id)
       rescue StandardError => e
         log_error(listener_class, method, e)
-        raise # Re-raise for sync listeners to maintain transaction integrity
+        raise
       end
 
       private
 
       def execute_listener(listener_class, method, record_class, record_id)
-        reloaded_record = record_class.find_by(id: record_id)
+        record = record_class.find_by(id: record_id)
 
-        if reloaded_record
-          listener_class.public_send(method, reloaded_record)
-        else
+        unless record
           Rails.logger&.warn(
-            "[Listenable] Record #{record_class}##{record_id} not found for #{listener_class}##{method}"
+            "[Listenable] #{record_class}##{record_id} not found for #{listener_class}##{method}"
           )
+          return
         end
+
+        listener_class.public_send(method, record)
       end
 
       def log_error(listener_class, method, error)
         Rails.logger&.error(
-          "[Listenable] #{listener_class}##{method} failed: #{error.message}\n#{error.backtrace.first(5).join("\n")}"
+          "[Listenable] #{listener_class}##{method} failed: " \
+          "#{error.message}\n#{error.backtrace.first(5).join("\n")}"
         )
       end
     end

data/lib/listenable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Listenable
-  VERSION = '0.3.0'
+  VERSION = '0.3.1'
 end

data/lib/listenable.rb

@@ -4,6 +4,7 @@ require 'active_support'
 require 'active_support/concern'
 require 'active_support/notifications'
 require 'concurrent'
+require 'set'
 
 require_relative 'listenable/version'
 require_relative 'listenable/concern'
@@ -12,24 +13,45 @@ require_relative 'listenable/railtie' if defined?(Rails)
 module Listenable
   mattr_accessor :enabled, default: true
 
+  # Connection pool safety configuration
+  mattr_accessor :connection_checkout_timeout, default: 5 # seconds
+  mattr_accessor :max_thread_pool_ratio, default: 0.25 # 25% of connection pool
+  mattr_accessor :max_thread_pool_size, default: 3 # absolute max threads
+
   class Error < StandardError; end
+  class ConnectionPoolExhausted < Error; end
 
   class << self
     attr_writer :async_executor
 
+    # Registry of all listener classes (better than ObjectSpace scan)
+    def listener_classes
+      @listener_classes ||= Set.new
+    end
+
+    # Register a listener class when Listenable is included
+    def register_listener(klass)
+      listener_classes.add(klass) if klass.name && !klass.name.empty?
+    end
+
+    # Clear registry on reload
+    def clear_listeners!
+      @listener_classes = Set.new
+    end
+
     # Track active subscribers to prevent memory leaks on reload
     def subscribers
       @subscribers ||= []
     end
 
     # Calculate a safe thread pool size based on connection pool
-    # Very conservative: use only 1/4 of pool (min 1, max 3)
+    # Very conservative: use configurable ratio of pool (default 25%)
     def default_thread_pool_size
       return 2 unless defined?(ActiveRecord::Base)
 
       pool_size = ActiveRecord::Base.connection_pool.size
-      # Use 25% of pool, but at least 1 thread, max 3 threads
-      [[pool_size / 4, 1].max, 3].min
+      # Use configured ratio of pool, but at least 1 thread, max configured limit
+      [[pool_size * max_thread_pool_ratio, 1].max, max_thread_pool_size].min.to_i
     end
 
     # Thread pool executor for async listeners
@@ -55,6 +77,9 @@ module Listenable
       end
       @subscribers = []
 
+      # Clear listener registry for fresh reload
+      clear_listeners!
+
       # Shutdown thread pool gracefully
       shutdown_async_executor!
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: listenable
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Den Meralpis
@@ -51,6 +51,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -118,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: A Rails DSL for model event listeners using ActiveSupport::Notifications.
 test_files: []