faye-redis-ng 1.0.6 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f87f5800dede3c5720fc5ab77944c3322f735cd808c1b02edd218fc6d97bca8b
-  data.tar.gz: 13d579f33d6620ab7ecdc3567b45dd7c4a58264ed0115b25ddc39454662b2e0c
+  metadata.gz: 4a2f33a6f83547306e5a0e52a70e2e8e06a236703c5a56bffc7cf85a829d0a54
+  data.tar.gz: 0e62be0064f4307be4a87d94ddce9e424d7ee4dbad9a85fdf41c03c7ed5db854
 SHA512:
-  metadata.gz: fbd69bad2590d4e55b141941952c95e316c3d8dd2a1e37f4ebbe3129ffe00b48957e8ba86c02732ef67aad97200c47b27dc6c663c5c41640cbaa0dd6787e8514
-  data.tar.gz: 8c08572629040c40e130f03c0881e864f02a1dbfb89b5db9c0509c255d4cf986a9f38bf5267c4834216dcae0ca26ef6c115742b42c4f61095c9e4cb14264824a
+  metadata.gz: f67fd292dd0bf0b9fb90a3af34fc7b8ae15627569090c303a06b58f89702124319a8ad96f75603cc38570c5881aa0f4ecaf0e0df39a43ad96ddb9483c3bac51e
+  data.tar.gz: 697a5b1bbd62ebd8f87da936ffc0aa3dc4cad84c9a010f4537dfd5e21c1ea1847ce0af757085bb3a4c7dc6f3a2952cf4c53e01d4a6f33e2fa4e714faffec61be

data/CHANGELOG.md

@@ -7,6 +7,54 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.7] - 2025-10-30
+
+### Fixed
+- **Critical: Publish Race Condition**: Fixed race condition in `publish` method where callback could be called multiple times
+  - Added `callback_called` flag to prevent duplicate callback invocations
+  - Properly track completion of all async operations before calling final callback
+  - Ensures `success` status is correctly aggregated from all operations
+  - **Impact**: Eliminates unreliable message delivery status in high-concurrency scenarios
+
+- **Critical: Thread Safety Issue**: Fixed thread safety issue in PubSubCoordinator message handling
+  - Changed `EventMachine.next_tick` to `EventMachine.schedule` for cross-thread safety
+  - Added reactor running check before scheduling
+  - Added error handling for subscriber callbacks
+  - **Impact**: Prevents undefined behavior when messages arrive from Redis pub/sub thread
+
+- **Message Deduplication**: Fixed duplicate message enqueue issue
+  - Local published messages were being enqueued twice (local + pub/sub echo)
+  - Added message ID tracking to filter out locally published messages from pub/sub
+  - Messages now include unique IDs for deduplication
+  - **Impact**: Eliminates duplicate messages in single-server deployments
+
+- **Batch Enqueue Logic**: Fixed `enqueue_messages_batch` to handle nil callbacks correctly
+  - Separated empty client list check from callback check
+  - Allows batch enqueue without callback (used by setup_message_routing)
+  - **Impact**: Fixes NoMethodError when enqueue is called without callback
+
+### Added
+- **Concurrency Test Suite**: Added comprehensive concurrency tests (spec/faye/redis_concurrency_spec.rb)
+  - Tests for callback guarantee (single invocation)
+  - Tests for concurrent publish operations
+  - Tests for multi-channel publishing
+  - Tests for error handling
+  - Stress test with 50 rapid publishes
+  - Thread safety tests
+
+### Technical Details
+**Publish Race Condition Fix**:
+- Before: Multiple async callbacks could decrement counter and call callback multiple times
+- After: Track completion with callback_called flag, ensure atomic callback invocation
+
+**Thread Safety Fix**:
+- Before: `EventMachine.next_tick` called from Redis subscriber thread (unsafe)
+- After: `EventMachine.schedule` safely queues work from any thread to EM reactor
+
+**Message Deduplication**:
+- Before: Message published locally → enqueued → published to Redis → received back → enqueued again
+- After: Track local message IDs, filter out self-published messages from pub/sub
+
 ## [1.0.6] - 2025-10-30
 
 ### Added
@@ -151,7 +199,8 @@ For 100 subscribers receiving one message:
 ### Security
 - Client and message IDs now use `SecureRandom.uuid` instead of predictable time-based generation
 
-[Unreleased]: https://github.com/7a6163/faye-redis-ng/compare/v1.0.6...HEAD
+[Unreleased]: https://github.com/7a6163/faye-redis-ng/compare/v1.0.7...HEAD
+[1.0.7]: https://github.com/7a6163/faye-redis-ng/compare/v1.0.6...v1.0.7
 [1.0.6]: https://github.com/7a6163/faye-redis-ng/compare/v1.0.5...v1.0.6
 [1.0.5]: https://github.com/7a6163/faye-redis-ng/compare/v1.0.4...v1.0.5
 [1.0.4]: https://github.com/7a6163/faye-redis-ng/compare/v1.0.3...v1.0.4

data/lib/faye/redis/pubsub_coordinator.rb

@@ -166,11 +166,21 @@ module Faye
         begin
           message = JSON.parse(message_json)
 
-          # Notify all subscribers (use dup to avoid concurrent modification)
-          EventMachine.next_tick do
-            @subscribers.dup.each do |subscriber|
-              subscriber.call(channel, message)
+          # Notify all subscribers
+          # Use EventMachine.schedule to safely call from non-EM thread
+          # (handle_message is called from subscriber_thread, not EM reactor thread)
+          if EventMachine.reactor_running?
+            EventMachine.schedule do
+              @subscribers.dup.each do |subscriber|
+                begin
+                  subscriber.call(channel, message)
+                rescue => e
+                  log_error("Subscriber callback error for #{channel}: #{e.message}")
+                end
+              end
             end
+          else
+            log_error("Cannot handle message: EventMachine reactor not running")
           end
         rescue JSON::ParserError => e
           log_error("Failed to parse message from #{channel}: #{e.message}")

data/lib/faye/redis/version.rb

@@ -1,5 +1,5 @@
 module Faye
   class Redis
-    VERSION = '1.0.6'
+    VERSION = '1.0.7'
   end
 end

data/lib/faye/redis.rb

@@ -105,34 +105,68 @@ module Faye
       channels = [channels] unless channels.is_a?(Array)
 
       begin
-        remaining_operations = channels.size
-        success = true
+        # Ensure message has an ID for deduplication
+        message = message.dup unless message.frozen?
+        message['id'] ||= generate_message_id
+
+        # Track this message as locally published
+        if @local_message_ids
+          if @local_message_ids_mutex
+            @local_message_ids_mutex.synchronize { @local_message_ids.add(message['id']) }
+          else
+            @local_message_ids.add(message['id'])
+          end
+        end
+
+        total_channels = channels.size
+        completed_channels = 0
+        callback_called = false
+        all_success = true
 
         channels.each do |channel|
           # Get subscribers and process in parallel
           @subscription_manager.get_subscribers(channel) do |client_ids|
-            # Immediately publish to pub/sub (don't wait for enqueue)
+            # Track operations for this channel
+            pending_ops = 2  # pubsub + enqueue
+            channel_success = true
+            ops_completed = 0
+
+            complete_channel = lambda do
+              ops_completed += 1
+              if ops_completed == pending_ops
+                # This channel is complete
+                all_success &&= channel_success
+                completed_channels += 1
+
+                # Call final callback when all channels are done
+                if completed_channels == total_channels && !callback_called && callback
+                  callback_called = true
+                  EventMachine.next_tick { callback.call(all_success) }
+                end
+              end
+            end
+
+            # Publish to pub/sub
             @pubsub_coordinator.publish(channel, message) do |published|
-              success &&= published
+              channel_success &&= published
+              complete_channel.call
             end
 
-            # Enqueue for all subscribed clients in parallel (batch operation)
+            # Enqueue for all subscribed clients
             if client_ids.any?
               enqueue_messages_batch(client_ids, message) do |enqueued|
-                success &&= enqueued
+                channel_success &&= enqueued
+                complete_channel.call
               end
-            end
-
-            # Track completion
-            remaining_operations -= 1
-            if remaining_operations == 0 && callback
-              EventMachine.next_tick { callback.call(success) }
+            else
+              # No clients, but still need to complete
+              complete_channel.call
             end
           end
         end
       rescue => e
         log_error("Failed to publish message to channels #{channels}: #{e.message}")
-        EventMachine.next_tick { callback.call(false) } if callback
+        EventMachine.next_tick { callback.call(false) } if callback && !callback_called
       end
     end
 
@@ -169,9 +203,20 @@ module Faye
       SecureRandom.uuid
     end
 
+    def generate_message_id
+      SecureRandom.uuid
+    end
+
     # Batch enqueue messages to multiple clients using a single Redis pipeline
     def enqueue_messages_batch(client_ids, message, &callback)
-      return EventMachine.next_tick { callback.call(true) } if client_ids.empty? || !callback
+      # Handle empty client list
+      if client_ids.empty?
+        EventMachine.next_tick { callback.call(true) } if callback
+        return
+      end
+
+      # No callback provided, but still need to enqueue
+      # (setup_message_routing calls this without callback)
 
       message_json = message.to_json
       message_ttl = @options[:message_ttl] || 3600
@@ -252,10 +297,31 @@ module Faye
     end
 
     def setup_message_routing
+      # Track locally published message IDs to avoid duplicate enqueue
+      @local_message_ids = Set.new
+      @local_message_ids_mutex = Mutex.new if defined?(Mutex)
+
       # Subscribe to message events from other servers
       @pubsub_coordinator.on_message do |channel, message|
+        # Skip if this is a message we just published locally
+        # (Redis pub/sub echoes back messages to the publisher)
+        message_id = message['id']
+        is_local = false
+
+        if message_id
+          if @local_message_ids_mutex
+            @local_message_ids_mutex.synchronize do
+              is_local = @local_message_ids.delete(message_id)
+            end
+          else
+            is_local = @local_message_ids.delete(message_id)
+          end
+        end
+
+        next if is_local
+
+        # Enqueue for remote servers' messages only
         @subscription_manager.get_subscribers(channel) do |client_ids|
-          # Use batch enqueue for better performance
           enqueue_messages_batch(client_ids, message) if client_ids.any?
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: faye-redis-ng
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.7
 platform: ruby
 authors:
 - Zac