activity_notification 2.5.0 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ac9e17e63d801b74604936ea099825e1eedd68c5f743b35c01e7af9e73d90ab
-  data.tar.gz: 07db03884cf03f86db283a7b5cbd92f7629277ea5f4f5a910629924471ff62e3
+  metadata.gz: 30af4a0429874914d32df8bdff256add7d9278b9f19bbd9c3a03f23138dac654
+  data.tar.gz: f08926e67ff5a91cfa3e80bc94af31bf4e7d19f2fb1198a75fa2d906a69bc17e
 SHA512:
-  metadata.gz: 91e6206957623ce19971e581afa07fe3b464b02273a968c17bbf145da5836aecbd9b0919b05fae844f912a003a9eeb0d2d4a1df011889ba6bcfb7d752c632346
-  data.tar.gz: 0efe5572854a47c271f6b79b1e0ad649b0d491c1ba4b5370a09a78a0876b4f684bf841069fbaba26fff24e3735ae6b11eeb9bf92ce75f359776d59fd526519ce
+  metadata.gz: ea7191de6c42a8898d63462595f3f46dc48f3d3cbc10c54e1fad225fcab8d3bb5be15d4c05015ff800a8e4090e2080f1943fa3d72d956b2b7a5404d6a88fe7b1
+  data.tar.gz: 85cfb749ccab3170964b270f405d24d6d715dc2d1f808ec95e18a8ce0fd14a30250cf83b3985869996358339b5b2b00807bd9b993599a034271288cecc9914ee

data/lib/activity_notification/apis/notification_api.rb

@@ -231,7 +231,8 @@ module ActivityNotification
           notify_later(target_type, notifiable, options)
         else
           targets = notifiable.notification_targets(target_type, options[:pass_full_options] ? options : options[:key])
-          unless targets.blank?
+          # Optimize blank check to avoid loading all records for ActiveRecord relations
+          unless targets_empty?(targets)
             notify_all(targets, notifiable, options)
           end
         end
@@ -272,10 +273,17 @@ module ActivityNotification
 
       # Generates notifications to specified targets.
       #
-      # @example Notify to all users
+      # For large target collections, this method uses batch processing to reduce memory consumption:
+      # - ActiveRecord::Relation: Uses find_each (loads in batches of 1000 records)
+      # - Mongoid::Criteria: Uses each with cursor batching
+      # - Arrays: Standard iteration (already in memory)
+      #
+      # @example Notify to all users (with ActiveRecord relation for memory efficiency)
       #   ActivityNotification::Notification.notify_all User.all, @comment
+      # @example Notify to all users with custom batch size
+      #   ActivityNotification::Notification.notify_all User.all, @comment, batch_size: 500
       #
-      # @param [Array<Object>] targets Targets to send notifications
+      # @param [ActiveRecord::Relation, Mongoid::Criteria, Array<Object>] targets Targets to send notifications
       # @param [Object] notifiable Notifiable instance
       # @param [Hash] options Options for notifications
       # @option options [String]                  :key                      (notifiable.default_notification_key) Key of the notification
@@ -287,23 +295,32 @@ module ActivityNotification
       # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
+      # @option options [Integer]                 :batch_size               (1000)                                Batch size for ActiveRecord find_each (optional)
       # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
       # @return [Array<Notificaion>] Array of generated notifications
       def notify_all(targets, notifiable, options = {})
         if options[:notify_later]
           notify_all_later(targets, notifiable, options)
         else
-          targets.map { |target| notify_to(target, notifiable, options) }
+          # Optimize for large ActiveRecord relations by using batch processing
+          process_targets_in_batches(targets, notifiable, options)
         end
       end
       alias_method :notify_all_now, :notify_all
 
       # Generates notifications to specified targets later by ActiveJob queue.
       #
+      # Note: When passing ActiveRecord relations or Mongoid criteria to async jobs,
+      # they may be serialized to arrays before job execution, which can consume memory
+      # for large target sets. For very large datasets (10,000+ records), consider using
+      # notify_later with target_type instead, which generates notifications asynchronously
+      # without loading all targets upfront:
+      #   ActivityNotification::Notification.notify(:users, @comment, notify_later: true)
+      #
       # @example Notify to all users later
       #   ActivityNotification::Notification.notify_all_later User.all, @comment
       #
-      # @param [Array<Object>] targets Targets to send notifications
+      # @param [ActiveRecord::Relation, Mongoid::Criteria, Array<Object>] targets Targets to send notifications
       # @param [Object] notifiable Notifiable instance
       # @param [Hash] options Options for notifications
       # @option options [String]                  :key                      (notifiable.default_notification_key) Key of the notification
@@ -549,6 +566,59 @@ module ActivityNotification
         notification.after_store
         notification
       end
+
+      # Checks if targets collection is empty without loading all records
+      # @api private
+      # @param [Object] targets Targets collection (can be an ActiveRecord::Relation, Mongoid::Criteria, Array, etc.)
+      # @return [Boolean] True if targets is empty
+      def targets_empty?(targets)
+        # For ActiveRecord relations and Mongoid criteria, use exists? to avoid loading all records
+        if targets.respond_to?(:exists?)
+          !targets.exists?
+        else
+          # For arrays and other enumerables, use blank?
+          targets.blank?
+        end
+      end
+
+      # Processes targets in batches for memory efficiency with large collections
+      # @api private
+      # 
+      # For ActiveRecord::Relation, uses find_each which loads records in batches (default 1000).
+      # For Mongoid::Criteria, uses each which leverages MongoDB's cursor batching.
+      # For Arrays and other enumerables, uses standard iteration.
+      # 
+      # Note: When called from async jobs (notify_all_later), ActiveRecord relations may be
+      # serialized to arrays before reaching this method, which limits batch processing benefits.
+      # Consider using notify_later with target_type instead of notify_all_later with relations
+      # for large datasets in async scenarios.
+      #
+      # @param [Object] targets Targets collection (can be an ActiveRecord::Relation, Mongoid::Criteria, Array, etc.)
+      # @param [Object] notifiable Notifiable instance
+      # @param [Hash] options Options for notifications
+      # @option options [Integer] :batch_size (1000) Batch size for ActiveRecord find_each (optional)
+      # @return [Array<Notification>] Array of generated notifications
+      def process_targets_in_batches(targets, notifiable, options = {})
+        notifications = []
+        
+        # For ActiveRecord relations, use find_each to process in batches
+        # This loads records in batches (default 1000) to avoid loading all records into memory
+        if targets.respond_to?(:find_each)
+          batch_options = {}
+          batch_options[:batch_size] = options[:batch_size] if options[:batch_size]
+          
+          targets.find_each(**batch_options) do |target|
+            notification = notify_to(target, notifiable, options)
+            notifications << notification
+          end
+        else
+          # For arrays and other enumerables, use standard map approach
+          # Already in memory, so no batching benefit
+          notifications = targets.map { |target| notify_to(target, notifiable, options) }
+        end
+        
+        notifications
+      end
     end
 
     # :nocov:

data/lib/activity_notification/version.rb

@@ -1,3 +1,3 @@
 module ActivityNotification
-  VERSION = "2.5.0"
+  VERSION = "2.5.1"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: activity_notification
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.5.1
 platform: ruby
 authors:
 - Shota Yamazaki
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -19,7 +18,7 @@ dependencies:
         version: 7.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.1'
+        version: '8.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +28,7 @@ dependencies:
         version: 7.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.1'
+        version: '8.2'
 - !ruby/object:Gem::Dependency
   name: i18n
   requirement: !ruby/object:Gem::Requirement
@@ -455,7 +454,6 @@ homepage: https://github.com/simukappu/activity_notification
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -470,8 +468,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Integrated user activity notifications for Ruby on Rails
 test_files: []