debounced 2.0.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23ca0ee42ff088cb85dd495dc84f5cffb38b2a6af402bab7b23424f962e8f002
-  data.tar.gz: 0e218d90fb5ad2d908cd20d3557dd6bf4aa7267f9461810c34d9f30b3c62d0ae
+  metadata.gz: c9fa1cd41e5d203718e5f338068db77acd8b07f15369c705e096f9a2108b7614
+  data.tar.gz: 544067be17e4efad251d656374b5d41a08c2c3ad627fc7f0ac75dbdf83be0c05
 SHA512:
-  metadata.gz: 2f16ed706132085f5109692d233544893edb540b1500a498f5597caef5fa856e8e1bdc06c3eae9a46251e8104537908f7b7f24aca8356c16331465fd1c2de250
-  data.tar.gz: '02438414f936b2d72c5dd185288892a9e12501e734977ae3d2103ca458c22e628c8ff83ea809f68c3c21084888ebc2fd2a7c5a1752fd42d9bdba5ab29feb7444'
+  metadata.gz: 7965f45c4e5055cf0c0e98123c6e88b5e7f1d9ef2ac6e0ecc1a3f09e51364b6feb2d5c3f07dc294d54a6f15af717cf6b6ccb87eae090466583f07f8ff6d162cd
+  data.tar.gz: 7165afce55d82ff97a1747181bd219e63a94ac79f23d0ec3b3ffbc04b4c6ce31f83be4b1a3372dd20484bae19db00f4546e7e4bc02f162efaf5dc560c4569fae

data/CHANGELOG.md

@@ -5,6 +5,36 @@ 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.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Fixed
+
+- Each process's descriptors are debounced separately. When two processes debounced the same descriptor, the later
+  request cancelled the earlier process's callback; now each process gets its own callback, and a process's pending
+  callbacks are cancelled when it disconnects
+
+## [2.1.0] - 2026-09-26
+
+### Security
+
+- Callbacks are only dispatched to public methods defined by the application, never to core Ruby methods
+- The server creates its socket owner-only, and the proxy refuses a socket owned by another user
+
+### Changed
+
+- Requires Node.js 22 or later; Node.js 18 and 20 are past end of life
+
+### Fixed
+
+- A second server no longer takes over the socket of a running one, and only removes a socket it created
+- The server exits non-zero when it cannot listen
+- Multi-byte characters split across socket reads are no longer corrupted
+- The server serves any number of connected processes and publishes each callback to the process that requested it
+- The listener no longer adds an extra idle timeout before delivering a callback
+- Requests larger than the socket buffer are no longer truncated
+- A failed send falls back to invoking the callback instead of raising
+- `ServiceProxy#stop` works before `listen`
+
 ## [1.0.7](https://github.com/Flytedesk/debounced/compare/v1.0.6...v1.0.7) (2026-04-15)
 
 

data/README.md

@@ -27,7 +27,7 @@ $ gem install debounced
 
 This gem requires Node.js to be installed on your system, as it uses a Node.js server to handle the debouncing logic. You'll need:
 
-- Node.js >= 20.0.0
+- Node.js >= 22.0.0
 
 ## Usage
 

data/lib/debounced/callback.rb

@@ -3,6 +3,8 @@ module Debounced
   ###
   # Represents a callback to be executed by the debounce service
   class Callback
+    CORE_RUBY_OWNERS = [BasicObject, Kernel, Object, Module, Class].freeze
+
     attr_accessor :class_name, :method_name, :args, :kwargs, :method_args, :method_kwargs
 
     ###
@@ -65,19 +67,32 @@ module Debounced
 
     def call
       Debounced.configuration.logger.debug("Invoking callback #{method_name}")
-      klass = Object.const_get(class_name)
-      unless klass.ancestors.include?(Debounced::Callbackable)
-        raise ArgumentError, "#{class_name} is not an allowed Debounced callback target. Include Debounced::Callbackable in the class."
-      end
+      klass = callback_class
       if klass.respond_to?(method_name)
-        klass.send(method_name, *args, **kwargs)
+        ensure_application_method(klass.method(method_name))
+        klass.public_send(method_name, *args, **kwargs)
       else
-        instance = klass.new(*args, **kwargs)
-        instance.send(method_name, *method_args, **method_kwargs)
+        ensure_application_method(klass.public_instance_method(method_name))
+        klass.new(*args, **kwargs).public_send(method_name, *method_args, **method_kwargs)
       end
     rescue StandardError => e
       Debounced.configuration.logger.warn("Unable to invoke callback #{as_json}: #{e.message}")
       Debounced.configuration.logger.warn(e.backtrace.join("\n"))
     end
+
+    private
+
+    def callback_class
+      klass = Object.const_get(class_name)
+      return klass if klass.ancestors.include?(Debounced::Callbackable)
+
+      raise ArgumentError, "#{class_name} is not an allowed Debounced callback target. Include Debounced::Callbackable in the class."
+    end
+
+    def ensure_application_method(method)
+      return unless CORE_RUBY_OWNERS.include?(method.owner)
+
+      raise ArgumentError, "#{method_name} is a core Ruby method and not an allowed Debounced callback"
+    end
   end
 end

data/lib/debounced/javascript/service.mjs

@@ -9,8 +9,7 @@ function log(message, ...args) {
 export default class DebounceService {
   constructor(socketDescriptor) {
     this._socketDescriptor = socketDescriptor;
-    this._timers = {};
-    this._client = null;
+    this._timers = new Map();
     this.publishEvent = this.publishEvent.bind(this);
     this.debounceEvent = this.debounceEvent.bind(this);
     this.reset = this.reset.bind(this);
@@ -18,28 +17,26 @@ export default class DebounceService {
     this.handleError = this.handleError.bind(this);
     this.sendMessage = this.sendMessage.bind(this);
     this.onClientConnected = this.onClientConnected.bind(this);
-    this.onClientDisconnected = this.onClientDisconnected.bind(this);
-    this.onConnectionError = this.onConnectionError.bind(this);
     this.handleMessage = this.handleMessage.bind(this);
     this.configureServer();
   }
 
   onConnectionError(err) {
     log('DebounceService client connection error');
-    this._client = null
     this.handleError(err);
   }
 
-  onClientDisconnected() {
+  onClientDisconnected(socket) {
     log('DebounceService client disconnected');
-    this._client = null
+    this._timers.get(socket).forEach(timerID => clearTimeout(timerID));
+    this._timers.delete(socket);
   }
 
-  handleMessage(message) {
+  handleMessage(message, socket) {
     try {
       const object = JSON.parse(message);
       if (object.type === 'debounceEvent') {
-        this.debounceEvent(object.data);
+        this.debounceEvent(object.data, socket);
       } else if (object.type === 'reset') {
         this.reset();
       } else {
@@ -51,68 +48,80 @@ export default class DebounceService {
   }
 
   onClientConnected(socket) {
-    if (this._client) {
-      log('DebounceService rejecting connection: client already connected');
-      this.sendMessage(socket, JSON.stringify({ type: 'rejectClient'}));
-      socket.destroy();
-      return;
-    }
-
     log('DebounceService client connected');
     let connectionBuffer = '';
-    this._client = socket;
-    socket.on('end', this.onClientDisconnected)
-    socket.on('error', this.onConnectionError)
+    this._timers.set(socket, new Map());
+    socket.on('close', () => this.onClientDisconnected(socket));
+    socket.on('error', this.onConnectionError);
+    socket.setEncoding('utf8');
     socket.on('data', data => {
-      log('DebounceService data received', data.toString());
-      connectionBuffer += data.toString();
+      log('DebounceService data received', data);
+      connectionBuffer += data;
       const messages = connectionBuffer.split('\f');
-      connectionBuffer = ''
-      if (!connectionBuffer.endsWith('\f')) {
-        connectionBuffer = messages.pop();
-      }
-      messages.forEach(this.handleMessage);
+      connectionBuffer = messages.pop();
+      messages.forEach(message => this.handleMessage(message, socket));
     })
   }
 
   configureServer() {
     this.server = net.createServer(this.onClientConnected)
-    this.server.on('error', this.handleError);
+    this.server.on('error', (err) => {
+      this.handleError(err);
+      process.exit(1);
+    });
   }
 
   cleanupDescriptor() {
     if (fs.existsSync(this._socketDescriptor)) {
-      log('DebounceEventService removing stale socket file ', this._socketDescriptor);
+      log('DebounceEventService removing socket file ', this._socketDescriptor);
       fs.unlinkSync(this._socketDescriptor);
     }
   }
 
   listen() {
-    // Remove the existing socket file if it exists
-    this.cleanupDescriptor()
+    if (!fs.existsSync(this._socketDescriptor)) {
+      this.bind();
+      return;
+    }
 
-    process.on('exit', (code) => {
-      log(`Process exiting with code: ${code}`);
-      this.server.close();
-      this.cleanupDescriptor()
+    const probe = net.connect(this._socketDescriptor);
+    probe.on('connect', () => {
+      probe.destroy();
+      log('DebounceEventService another server is listening on', this._socketDescriptor);
+      process.exit(1);
     });
+    probe.on('error', (err) => {
+      if (err.code !== 'ECONNREFUSED') {
+        this.handleError(err);
+        process.exit(1);
+      }
+      log('DebounceEventService removing stale socket file ', this._socketDescriptor);
+      fs.unlinkSync(this._socketDescriptor);
+      this.bind();
+    });
+  }
 
-    process.on('SIGTERM', () => {
-      log('Process received SIGTERM');
-      this.server.close();
-      this.cleanupDescriptor()
-      process.exit(0);
+  bind() {
+    const previousUmask = process.umask(0o177);
+    this.server.listen(this._socketDescriptor, () => {
+      log('DebounceService listening on', this._socketDescriptor);
+      this.cleanupOnExit();
     });
+    process.umask(previousUmask);
+  }
 
-    process.on('SIGINT', () => {
-      log('Process received SIGINT');
+  cleanupOnExit() {
+    process.on('exit', (code) => {
+      log(`Process exiting with code: ${code}`);
       this.server.close();
-      this.cleanupDescriptor()
-      process.exit(0);
+      this.cleanupDescriptor();
     });
 
-    this.server.listen(this._socketDescriptor, () => {
-      log('DebounceService listening on', this._socketDescriptor);
+    ['SIGTERM', 'SIGINT'].forEach((signal) => {
+      process.on(signal, () => {
+        log(`Process received ${signal}`);
+        process.exit(0);
+      });
     });
   }
 
@@ -125,30 +134,31 @@ export default class DebounceService {
     }
   }
 
-  publishEvent(descriptor, callback) {
+  publishEvent(descriptor, callback, socket) {
     log(`Debounce period expired for ${descriptor} - sending to client`);
     const message = JSON.stringify({
       type: 'publishEvent',
       callback: callback
     });
-    this.sendMessage(this._client, message);
+    this.sendMessage(socket, message);
   }
 
-  debounceEvent({ descriptor, timeout, callback }) {
-    if (this._timers[descriptor]) {
-      clearTimeout(this._timers[descriptor]);
-    }
+  debounceEvent({ descriptor, timeout, callback }, socket) {
+    const timers = this._timers.get(socket);
+    clearTimeout(timers.get(descriptor));
 
     log("Debouncing", descriptor);
-    this._timers[descriptor] = setTimeout(() => {
-      delete this._timers[descriptor];
-      this.publishEvent(descriptor, callback);
-    }, timeout * 1000);
+    timers.set(descriptor, setTimeout(() => {
+      timers.delete(descriptor);
+      this.publishEvent(descriptor, callback, socket);
+    }, timeout * 1000));
   }
 
   reset() {
-    Object.values(this._timers).forEach(timerID => clearTimeout(timerID));
-    this._timers = {};
+    this._timers.forEach(timers => {
+      timers.forEach(timerID => clearTimeout(timerID));
+      timers.clear();
+    });
   }
 
   handleError(err) {

data/lib/debounced/service_proxy.rb

@@ -48,6 +48,10 @@ module Debounced
           transmit(build_request(activity_descriptor, timeout, callback))
         end
       end
+    rescue IOError, SystemCallError, NoServerError => e
+      logger.warn("Unable to send #{activity_descriptor} to #{server_name} (#{e.message}); skipping debounce step.")
+      close
+      callback.call
     end
 
     ###
@@ -65,7 +69,6 @@ module Debounced
           next unless message
 
           payload = deserialize_message(message)
-          raise SocketConflictError if payload['type'] == 'rejectClient'
 
           instantiate_callback(payload['callback']).call
         rescue Debounced::NoServerError => e
@@ -75,7 +78,7 @@ module Debounced
 
         close
       end
-    rescue SocketConflictError, StandardError => e
+    rescue StandardError => e
       logger.warn("Unable to listen for messages from #{server_name}: #{e.message}")
       logger.warn(e.backtrace.join("\n"))
     ensure
@@ -83,17 +86,19 @@ module Debounced
     end
 
     def stop
-      @abort_signal.make_true
+      @abort_signal&.make_true
     end
 
     private
 
     def close
-      return unless @socket
+      @mutex.synchronize do
+        return unless @socket
 
-      logger.debug("Closing connection to #{server_name}")
-      @socket.close
-      @socket = nil
+        logger.debug("Closing connection to #{server_name}")
+        @socket.close
+        @socket = nil
+      end
     end
 
     def receive_message_from_server
@@ -108,7 +113,6 @@ module Debounced
       message
     rescue IO::TimeoutError
       logger_trace { "Timeout waiting for data" }
-      sleep wait_timeout
       nil
     rescue Errno::EPIPE, IOError, Errno::ECONNRESET
       close
@@ -127,7 +131,8 @@ module Debounced
     end
 
     def transmit(message)
-      socket.send serialize_message(message), 0
+      connection = socket or raise NoServerError, "#{server_name} at #{socket_descriptor} not running"
+      connection.write(serialize_message(message))
     end
 
     def server_name
@@ -154,6 +159,7 @@ module Debounced
     def socket
       @mutex.synchronize do
         return @socket if @socket
+        return unless File.owned?(socket_descriptor)
 
         logger_trace { "Connecting to #{server_name} at #{socket_descriptor}" }
         @socket = UNIXSocket.new(socket_descriptor).tap { |s| s.timeout = wait_timeout }

data/lib/debounced/version.rb

@@ -1,3 +1,3 @@
 module Debounced
-  VERSION = "2.0.0"
+  VERSION = "2.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: debounced
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Gary Passero