debounced 2.1.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9fa1cd41e5d203718e5f338068db77acd8b07f15369c705e096f9a2108b7614
-  data.tar.gz: 544067be17e4efad251d656374b5d41a08c2c3ad627fc7f0ac75dbdf83be0c05
+  metadata.gz: 545ffc360ed1f13cb95fbec250c45bed7744f932cb8865890019594c3ec30be3
+  data.tar.gz: 7a2e349b770b02a29c108af1c6fed682901971afebf9fac5b272dab4570eccbf
 SHA512:
-  metadata.gz: 7965f45c4e5055cf0c0e98123c6e88b5e7f1d9ef2ac6e0ecc1a3f09e51364b6feb2d5c3f07dc294d54a6f15af717cf6b6ccb87eae090466583f07f8ff6d162cd
-  data.tar.gz: 7165afce55d82ff97a1747181bd219e63a94ac79f23d0ec3b3ffbc04b4c6ce31f83be4b1a3372dd20484bae19db00f4546e7e4bc02f162efaf5dc560c4569fae
+  metadata.gz: c64730cb742be03954ca2caaf8b3145c4c7a2e016b9f65d5a737dfda3e8d51d49f98aad35d213abf2aacb360ff9b5e83f29a5cf4cdcb98154a60c40c31a40698
+  data.tar.gz: 4fe5b3d2563d3cadd547c9e7beac16811ff421716151eb4bdb184b2c7c39a7527729c44b0d269a03ef37db08ca91505445bd6446e07bb43b007c1357d8b6840c

data/CHANGELOG.md

@@ -5,34 +5,32 @@ 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
+## [3.0.0] - Unreleased
 
 ### Changed
 
-- Requires Node.js 22 or later; Node.js 18 and 20 are past end of life
+- The debounce server is now written in Ruby (`Debounced::Server`, on the `async` gem); Node.js is no longer required
+- Start it with `bundle exec rake debounced:server`, as before
+- Requires Ruby 3.3 or later
+- The server serves any number of connected processes and debounces each process's descriptors separately, publishing each callback to the process that requested it
+- On SIGTERM the server fires its pending timers on schedule, publishes new requests immediately, and exits once
+  nothing is pending; SIGINT still exits immediately
+- `ServiceProxy#stop(timeout:)` first waits up to `timeout` seconds for the server to close the connection, so a
+  process can receive the callbacks still pending when it shuts down
+- `Debounced.configuration.error_handler` — an optional callable, invoked with the error and the `Debounced::Callback`
+  when a callback raises, so a host app can report callback failures to an error tracker without the gem depending on one
 
 ### 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
+- The gem now depends on and requires `concurrent-ruby` directly, rather than relying on `semantic_logger` to pull it in
+  transitively (`ServiceProxy` uses `Concurrent::AtomicBoolean`)
+- Callbacks are only dispatched to public methods defined by the application, never to core Ruby methods
+- The socket is created owner-only, and the proxy refuses a socket owned by another user
+- A second server no longer takes over the socket of a running one
 - Requests larger than the socket buffer are no longer truncated
 - A failed send falls back to invoking the callback instead of raising
+- Callbacks are no longer delayed by an extra idle timeout in the listener
+- Multi-byte characters split across socket reads are no longer corrupted
 - `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

@@ -23,12 +23,6 @@ Or install it yourself as:
 $ gem install debounced
 ```
 
-## Dependencies
-
-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 >= 22.0.0
-
 ## Usage
 
 ### Configuration
@@ -43,10 +37,10 @@ end
 
 ### Starting the server
 
-Start the nodeJS debounce server with:
+Start the debounce server with:
 
 ```bash
-$ bundle exec debounced:server
+$ bundle exec rake debounced:server
 ```
 
 In your Ruby application code:
@@ -95,12 +89,48 @@ proxy.debounce_activity("my-event-123", 5, event.debounce_callback)
 # > Publishing event: #<MyEvent:0x00007f9b1b8b3b40 @test_id="Hello World">
 ```
 
+### Shutting down
+
+On SIGTERM the server stops debouncing: pending timers still fire on schedule, requests that arrive afterwards are
+published immediately, and once nothing is pending the server closes its connections and exits. Keep debounce
+timeouts shorter than your platform's shutdown grace period (30 seconds on Heroku).
+
+So that a process receives the callbacks still pending when it shuts down, stop the proxy with a timeout before
+exiting:
+
+```ruby
+at_exit { proxy.stop(timeout: 10) }
+```
+
+It waits until the server closes the connection or the timeout passes, and returns at once when not connected.
+SIGINT stops the server immediately, which is convenient in development.
+
 ## How It Works
 
-1. The gem creates a Unix socket for communication between Ruby and Node.js
-2. When you call `debounce_activity`, it sends the event to the Node.js server
-3. The Node.js server restarts a timer every time an event with a given activity_descriptor is received
-4. When the timeout expires, it sends the event back to Ruby to be published
+1. The debounce server listens on a Unix socket and runs one lightweight timer per activity descriptor
+2. When you call `debounce_activity`, the proxy sends the descriptor, timeout and callback to the server
+3. Each new request for the same descriptor cancels its timer and starts a new one, keeping the latest callback
+4. When a timer expires, the server sends the callback back to the proxy, which invokes it
+
+Several processes can connect to one server, for example every Puma worker of an application. Each process's
+descriptors are debounced separately, even when two processes use the same descriptor: each gets its own callback,
+and a process's pending callbacks are dropped when it disconnects.
+When no server is reachable, the proxy invokes callbacks immediately.
+
+## Performance
+
+Measured with `bin/benchmark`, which drives a server process over its socket. Medians of three runs on an Apple M4 Max,
+Ruby 4.0.4, compared with the Node.js server from `debounced` 2.1.0 on Node.js 24.18.
+
+| Measure | Ruby server (3.0) | Node.js server (2.1) |
+|---|---|---|
+| Throughput: 100,000 requests across 10,000 descriptors | 224,000 requests/s | 263,000 requests/s |
+| Callback lateness after its timeout, median | 0.25 ms | 0.26 ms |
+| Callback lateness, 99th percentile | 1.96 ms | 1.95 ms |
+| Memory, idle | 27 MB | 48 MB |
+| Memory, 100,000 pending timers | 156 MB | 174 MB |
+
+To measure another server, pass its command: `bin/benchmark node path/to/server.mjs`.
 
 ## License
 

data/lib/debounced/callback.rb

@@ -78,6 +78,7 @@ module Debounced
     rescue StandardError => e
       Debounced.configuration.logger.warn("Unable to invoke callback #{as_json}: #{e.message}")
       Debounced.configuration.logger.warn(e.backtrace.join("\n"))
+      Debounced.configuration.error_handler&.call(e, self)
     end
 
     private

data/lib/debounced/server.rb

@@ -0,0 +1,162 @@
+require 'async'
+require 'async/barrier'
+require 'async/notification'
+require 'async/queue'
+require 'io/event'
+require 'json'
+require 'socket'
+
+module Debounced
+  class Server
+    def initialize(socket_descriptor)
+      @socket_descriptor = socket_descriptor
+      @timers = {}
+      @writers = Async::Barrier.new
+      @queue = IO::Event::Timers.new
+      @timer_scheduled = Async::Notification.new
+    end
+
+    def listen
+      remove_stale_socket_file
+      Sync do |task|
+        @root = task
+        server = bind_owner_only
+        logger.info("#{self.class.name} listening on #{@socket_descriptor}")
+        task.async { run_timers }
+        task.async { drain_on_sigterm }
+        loop do
+          connection = server.accept
+          task.async { serve(connection) }
+        end
+      ensure
+        File.delete(@socket_descriptor) if server
+      end
+    end
+
+    private
+
+    def bind_owner_only
+      previous_umask = File.umask(0o177)
+      UNIXServer.new(@socket_descriptor)
+    ensure
+      File.umask(previous_umask)
+    end
+
+    def serve(connection)
+      logger.info('Client connected')
+      outbox = Async::Queue.new
+      @timers[outbox] = {}
+      @writers.async { write_messages(connection, outbox) }
+      while (line = connection.gets(ServiceProxy::DELIMITER, chomp: true))
+        handle(line, outbox)
+      end
+    rescue IOError, SystemCallError => e
+      logger.warn("Client connection error: #{e.message}")
+    ensure
+      logger.info('Client disconnected')
+      @timers.delete(outbox)&.each_value(&:cancel!)
+      outbox.close
+      connection.close
+      stop_if_drained
+    end
+
+    def write_messages(connection, outbox)
+      outbox.each { |message| send_message(connection, message) }
+    rescue IOError, SystemCallError => e
+      logger.warn("Unable to write to client: #{e.message}")
+    end
+
+    def handle(line, outbox)
+      message = JSON.parse(line)
+      case message['type']
+      when 'debounceEvent' then debounce(message['data'], outbox)
+      when 'reset' then reset
+      else logger.warn("Unknown message: #{line}")
+      end
+    rescue JSON::ParserError => e
+      logger.warn("Unable to parse message: #{e.message}")
+    end
+
+    def debounce(data, outbox)
+      descriptor = data['descriptor']
+      timers = @timers.fetch(outbox)
+      timers.delete(descriptor)&.cancel!
+      if @draining
+        publish(descriptor, data['callback'], outbox)
+        return stop_if_drained
+      end
+
+      logger.debug { "Debouncing #{descriptor}" }
+      timers[descriptor] = @queue.after(data['timeout']) do
+        timers.delete(descriptor)
+        publish(descriptor, data['callback'], outbox)
+        stop_if_drained
+      end
+      @timer_scheduled.signal
+    end
+
+    def drain_on_sigterm
+      signals, signal_writer = IO.pipe
+      Signal.trap('TERM') { signal_writer.write_nonblock('.', exception: false) }
+      signals.read(1)
+      logger.info('Received SIGTERM; firing pending timers, then exiting')
+      @draining = true
+      stop_if_drained
+    end
+
+    def stop_if_drained
+      finish_draining if @draining && @timers.each_value.all?(&:empty?)
+    end
+
+    def finish_draining
+      @draining = false
+      @timers.each_key(&:close)
+      @writers.wait
+      @root.stop
+    end
+
+    def run_timers
+      loop do
+        wait_for_next_deadline
+        @queue.fire
+      end
+    end
+
+    def wait_for_next_deadline
+      interval = @queue.wait_interval
+      if interval.nil?
+        @timer_scheduled.wait
+      elsif interval.positive?
+        Async::Task.current.with_timeout(interval) { @timer_scheduled.wait }
+      end
+    rescue Async::TimeoutError
+      nil
+    end
+
+    def publish(descriptor, callback, outbox)
+      logger.debug { "Debounce period expired for #{descriptor}" }
+      outbox.push(type: 'publishEvent', callback:)
+    end
+
+    def reset
+      @timers.each_value { |timers| timers.each_value(&:cancel!).clear }
+    end
+
+    def send_message(connection, message)
+      connection.write(JSON.generate(message), ServiceProxy::DELIMITER)
+    end
+
+    def remove_stale_socket_file
+      return unless File.exist?(@socket_descriptor)
+
+      UNIXSocket.new(@socket_descriptor).close
+      raise SocketConflictError, "Another server is listening on #{@socket_descriptor}"
+    rescue Errno::ECONNREFUSED
+      File.delete(@socket_descriptor)
+    end
+
+    def logger
+      Debounced.configuration.logger
+    end
+  end
+end

data/lib/debounced/service_proxy.rb

@@ -1,3 +1,4 @@
+require 'concurrent/atomic/atomic_boolean'
 require 'socket'
 require 'json'
 
@@ -49,7 +50,7 @@ module Debounced
         end
       end
     rescue IOError, SystemCallError, NoServerError => e
-      logger.warn("Unable to send #{activity_descriptor} to #{server_name} (#{e.message}); skipping debounce step.")
+      logger.warn("Unable to send #{activity_descriptor} (#{e.message}); skipping debounce step.")
       close
       callback.call
     end
@@ -85,12 +86,25 @@ module Debounced
       @listening = false
     end
 
-    def stop
+    ###
+    # Stop listening. With a timeout, first wait up to that many seconds for the server to close the connection, which it
+    # does once it has drained after SIGTERM, so the callbacks still pending arrive before the process exits.
+    def stop(timeout: 0)
+      deadline = monotonic_now + timeout
+      sleep 0.05 while connected? && monotonic_now < deadline
       @abort_signal&.make_true
     end
 
     private
 
+    def connected?
+      listening && @mutex.synchronize { !@socket.nil? }
+    end
+
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
     def close
       @mutex.synchronize do
         return unless @socket

data/lib/debounced/version.rb

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

data/lib/debounced.rb

@@ -21,7 +21,7 @@ module Debounced
   end
 
   class Configuration
-    attr_accessor :socket_descriptor, :wait_timeout, :enable_trace_logging
+    attr_accessor :socket_descriptor, :wait_timeout, :enable_trace_logging, :error_handler
 
     def initialize
       @socket_descriptor = ENV['DEBOUNCED_SOCKET'] || '/tmp/app.debounceEvents'

data/lib/tasks/debounced.rake

@@ -1,16 +1,9 @@
 namespace :debounced do
   desc 'Start the debounce server'
-  task :server => :environment do
+  task server: :environment do
     require 'debounced'
+    require 'debounced/server'
 
-    # Configuration is available because environment is loaded
-    socket_descriptor = Debounced.configuration.socket_descriptor
-
-    # Find the gem's JavaScript files
-    gem_lib_path = Pathname.new(Gem::Specification.find_by_name('debounced').gem_dir).join('lib')
-    js_path = gem_lib_path.join('debounced', 'javascript', 'server.mjs')
-
-    # Exec replaces the current process with the node process
-    exec("node #{js_path} #{socket_descriptor}")
+    Debounced::Server.new(Debounced.configuration.socket_descriptor).listen
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: debounced
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Gary Passero
@@ -10,33 +10,87 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: json
+  name: async
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.19'
+        version: '2.46'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.46'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: io-event
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.19'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.19'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: semantic_logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.17'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.17'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -85,7 +139,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.0
-description: Leverage JavaScript micro-event loop to debounce events in Ruby applications
+description: Debounce Ruby callbacks across processes through a lightweight Ruby timer
+  server
 email:
 - gary@flytedesk.com
 executables: []
@@ -97,20 +152,19 @@ files:
 - lib/debounced.rb
 - lib/debounced/callback.rb
 - lib/debounced/callbackable.rb
-- lib/debounced/javascript/server.mjs
-- lib/debounced/javascript/service.mjs
 - lib/debounced/no_server_error.rb
 - lib/debounced/railtie.rb
+- lib/debounced/server.rb
 - lib/debounced/service_proxy.rb
 - lib/debounced/socket_conflict_error.rb
 - lib/debounced/version.rb
 - lib/tasks/debounced.rake
-homepage: https://github.com/flytedesk/debounced
+homepage: https://github.com/Flytedesk/debounced-rb
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/flytedesk/debounced
-  changelog_uri: https://github.com/flytedesk/debounced/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/Flytedesk/debounced-rb
+  changelog_uri: https://github.com/Flytedesk/debounced-rb/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -118,14 +172,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Efficient event debouncing in Ruby
 test_files: []

data/lib/debounced/javascript/server.mjs

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-
-import DebounceEventService from './service.mjs'
-let socketDescriptor = '/tmp/app.debounceEvents';
-if (process.argv.length > 2) {
-  socketDescriptor = process.argv[2];
-}
-
-new DebounceEventService(socketDescriptor).listen();

data/lib/debounced/javascript/service.mjs

@@ -1,167 +0,0 @@
-import net from 'net';
-import fs from 'fs';
-
-function log(message, ...args) {
-  const timestamp = new Date().toISOString();
-  console.log(`${timestamp} - ${message}`, ...args);
-}
-
-export default class DebounceService {
-  constructor(socketDescriptor) {
-    this._socketDescriptor = socketDescriptor;
-    this._timers = new Map();
-    this.publishEvent = this.publishEvent.bind(this);
-    this.debounceEvent = this.debounceEvent.bind(this);
-    this.reset = this.reset.bind(this);
-    this.listen = this.listen.bind(this);
-    this.handleError = this.handleError.bind(this);
-    this.sendMessage = this.sendMessage.bind(this);
-    this.onClientConnected = this.onClientConnected.bind(this);
-    this.handleMessage = this.handleMessage.bind(this);
-    this.configureServer();
-  }
-
-  onConnectionError(err) {
-    log('DebounceService client connection error');
-    this.handleError(err);
-  }
-
-  onClientDisconnected(socket) {
-    log('DebounceService client disconnected');
-    this._timers.get(socket).forEach(timerID => clearTimeout(timerID));
-    this._timers.delete(socket);
-  }
-
-  handleMessage(message, socket) {
-    try {
-      const object = JSON.parse(message);
-      if (object.type === 'debounceEvent') {
-        this.debounceEvent(object.data, socket);
-      } else if (object.type === 'reset') {
-        this.reset();
-      } else {
-        log('DebounceService unknown message', message);
-      }
-    } catch (e) {
-      log('unable to parse message', e);
-    }
-  }
-
-  onClientConnected(socket) {
-    log('DebounceService client connected');
-    let connectionBuffer = '';
-    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);
-      connectionBuffer += data;
-      const messages = connectionBuffer.split('\f');
-      connectionBuffer = messages.pop();
-      messages.forEach(message => this.handleMessage(message, socket));
-    })
-  }
-
-  configureServer() {
-    this.server = net.createServer(this.onClientConnected)
-    this.server.on('error', (err) => {
-      this.handleError(err);
-      process.exit(1);
-    });
-  }
-
-  cleanupDescriptor() {
-    if (fs.existsSync(this._socketDescriptor)) {
-      log('DebounceEventService removing socket file ', this._socketDescriptor);
-      fs.unlinkSync(this._socketDescriptor);
-    }
-  }
-
-  listen() {
-    if (!fs.existsSync(this._socketDescriptor)) {
-      this.bind();
-      return;
-    }
-
-    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();
-    });
-  }
-
-  bind() {
-    const previousUmask = process.umask(0o177);
-    this.server.listen(this._socketDescriptor, () => {
-      log('DebounceService listening on', this._socketDescriptor);
-      this.cleanupOnExit();
-    });
-    process.umask(previousUmask);
-  }
-
-  cleanupOnExit() {
-    process.on('exit', (code) => {
-      log(`Process exiting with code: ${code}`);
-      this.server.close();
-      this.cleanupDescriptor();
-    });
-
-    ['SIGTERM', 'SIGINT'].forEach((signal) => {
-      process.on(signal, () => {
-        log(`Process received ${signal}`);
-        process.exit(0);
-      });
-    });
-  }
-
-  sendMessage(socket, message) {
-    try {
-      socket.write(message);
-      socket.write("\f");
-    } catch (err) {
-      this.handleError(err);
-    }
-  }
-
-  publishEvent(descriptor, callback, socket) {
-    log(`Debounce period expired for ${descriptor} - sending to client`);
-    const message = JSON.stringify({
-      type: 'publishEvent',
-      callback: callback
-    });
-    this.sendMessage(socket, message);
-  }
-
-  debounceEvent({ descriptor, timeout, callback }, socket) {
-    const timers = this._timers.get(socket);
-    clearTimeout(timers.get(descriptor));
-
-    log("Debouncing", descriptor);
-    timers.set(descriptor, setTimeout(() => {
-      timers.delete(descriptor);
-      this.publishEvent(descriptor, callback, socket);
-    }, timeout * 1000));
-  }
-
-  reset() {
-    this._timers.forEach(timers => {
-      timers.forEach(timerID => clearTimeout(timerID));
-      timers.clear();
-    });
-  }
-
-  handleError(err) {
-    log('\n\n######\nERROR: ', err);
-  }
-}