debounced 0.1.16 → 0.1.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e67d6eb56f33212d1f33d07015a9b3b5ea913f8c614b49a45586bfa65c9877d
-  data.tar.gz: fe8305b86ae64080de06614a0249b92f92dbac9e29e58b97c3250ad4a78063fd
+  metadata.gz: beb111cd5043d97b903d9e89278437564f65fd5794f4531d6e5c6e57dca79859
+  data.tar.gz: b872450de202d28e51d32eac774b27238a328972a7b3363c0ca77d5b137897f4
 SHA512:
-  metadata.gz: f758d65446f5fe6268be7e5cb1d90501188705b1fe55c378bfcc0012343b4971f57f6cc92de67d5fa44459628cb9d7e97f25c63b45b520027974cea9943f49c4
-  data.tar.gz: 350077a5ca3cea461e0746b4fabc5cc43d92c2ce347f3fe316768bfe7bd6c1aa75eeb53d9b44993b7ea1fe59ab1d5be390be04caf39ca630de4e6c43a3b4f63f
+  metadata.gz: f70040e9197b72f7e8b91b6bae9d736a3f840c6da34817722949f23a4d82c6b798a9a0011345ca623ba7bd4fc2bab48fa498d41cebf70dd59a9d7459d277416d
+  data.tar.gz: af31341ddf36fa276c5ad79db3cecdf975795bd1ac130005f18b9cbbab880b157645aa7e2d5c63199a98b999eae1b85e9daee061a2717162c27567d1d11c2564

data/lib/debounced/javascript/server.mjs

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 
-import DebounceEventService from './debounce.mjs'
+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

@@ -0,0 +1,140 @@
+import net from 'net';
+import fs from 'fs';
+
+export default class DebounceService {
+  constructor(socketDescriptor) {
+    this._socketDescriptor = socketDescriptor;
+    this._timers = {};
+    this._client = null;
+    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.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) {
+    console.log('DebounceService client connection error');
+    this._client = null
+    this.handleError(err);
+  }
+
+  onClientDisconnected() {
+    console.log('DebounceService client disconnected');
+    this._client = null
+  }
+
+  handleMessage(message) {
+    try {
+      const object = JSON.parse(message);
+      if (object.type === 'debounceEvent') {
+        this.debounceEvent(object.data);
+      } else if (object.type === 'reset') {
+        this.reset();
+      } else {
+        console.log('DebounceService unknown message', message);
+      }
+    } catch (e) {
+      console.log('unable to parse message', e);
+    }
+  }
+
+  onClientConnected(socket) {
+    if (this._client) {
+      console.log('DebounceService rejecting connection: already has a client');
+      socket.end();
+      return;
+    }
+
+    console.log('DebounceService client connected');
+    let connectionBuffer = '';
+    this._client = socket;
+    socket.on('end', this.onClientDisconnected)
+    socket.on('error', this.onConnectionError)
+    socket.on('data', data => {
+      console.log('DebounceService data received', data.toString());
+      connectionBuffer += data.toString();
+      const messages = connectionBuffer.split('\f');
+      connectionBuffer = ''
+      if (!connectionBuffer.endsWith('\f')) {
+        connectionBuffer = messages.pop();
+      }
+      messages.forEach(this.handleMessage);
+    })
+  }
+
+  configureServer() {
+    this.server = net.createServer(this.onClientConnected)
+    this.server.on('error', this.handleError);
+  }
+
+  listen() {
+    // Remove the existing socket file if it exists
+    if (fs.existsSync(this._socketDescriptor)) {
+      console.log('DebounceEventService removing stale socket file ', this._socketDescriptor);
+      fs.unlinkSync(this._socketDescriptor);
+    }
+
+    process.on('exit', (code) => {
+      console.log(`Process exiting with code: ${code}`);
+      this.server.close();
+    });
+
+    process.on('SIGTERM', () => {
+      console.log('Process received SIGTERM');
+      this.server.close();
+      process.exit(0);
+    });
+
+    process.on('SIGINT', () => {
+      console.log('Process received SIGINT');
+      this.server.close();
+      process.exit(0);
+    });
+
+    this.server.listen(this._socketDescriptor, () => {
+      console.log('DebounceService listening on', this._socketDescriptor);
+    });
+  }
+
+  publishEvent(descriptor, data) {
+    console.log(`Debounce period expired for ${descriptor}, publishing ${data.klass} event`);
+    const message = JSON.stringify({
+      type: 'publishEvent',
+      data: data
+    });
+
+    try {
+      this._client.write(message);
+      this._client.write("\f");
+    } catch (err) {
+      this.handleError(err);
+    }
+  }
+
+  debounceEvent({ descriptor, attributes, klass, timeout }) {
+    if (this._timers[descriptor]) {
+      clearTimeout(this._timers[descriptor]);
+    }
+
+    console.log("Debouncing", descriptor);
+    this._timers[descriptor] = setTimeout(() => {
+      delete this._timers[descriptor];
+      this.publishEvent(descriptor, { attributes, klass });
+    }, timeout * 1000);
+  }
+
+  reset() {
+    Object.values(this._timers).forEach(timerID => clearTimeout(timerID));
+    this._timers = {};
+  }
+
+  handleError(err) {
+    console.log('\n\n######\nERROR: ', err);
+  }
+}

data/lib/debounced/service_proxy.rb

@@ -1,7 +1,14 @@
 require 'socket'
-require 'active_support/json'
+require 'json'
+require 'json/add/core'
+require 'debug'
 
 module Debounced
+  ###
+  # Ruby interface to the debounce service
+  # Input is an activity descriptor, and an object.
+  # When the activity is debounced, a callback method is invoked on the object.
+  # Assumes the object class has an initializer that accepts a hash of attributes, which are the instance variables
   class ServiceProxy
     DELIMITER = "\f".freeze
 
@@ -11,16 +18,12 @@ module Debounced
 
     def listen(abort_signal = nil)
       Thread.new do
-        if defined?(Rails)
-          Rails.application.executor.wrap do
-            receive(abort_signal)
-          end
-        else
-          receive(abort_signal)
-        end
+        receive(abort_signal)
       end
     end
 
+    ###
+    # Send message to server to reset its state. Useful for automated testing.
     def reset
       if socket.nil?
         log_debug("No connection to #{server_name}; unable to reset server.")
@@ -30,13 +33,13 @@ module Debounced
       end
     end
 
-    def debounce(descriptor, object, timeout)
+    def debounce_activity(activity_descriptor, object, timeout)
       if socket.nil?
-        log_debug("No connection to #{server_name}; publishing event immediately.")
-        object_callback(object)
+        log_debug("No connection to #{server_name}; skipping debounce step.")
+        trigger_callback(object)
       else
         log_debug("Sending #{object.inspect} to #{server_name}")
-        transmit(debounce_request(descriptor, object, timeout))
+        transmit(build_request(activity_descriptor, object, timeout))
       end
     end
 
@@ -47,25 +50,27 @@ module Debounced
         break if abort_signal&.set?
 
         if socket.nil?
-          log_debug("Waiting for #{server_name}...")
+          log_debug("Waiting for #{server_name} to start...")
           sleep(@wait_timeout)
           next
         end
 
+        log_debug("Waiting for data from #{server_name}...")
         message = socket.gets(DELIMITER, chomp: true)
-
-        # gets => nil when server crashed.... try to reconnect
         if message.nil?
+          log_info("Server #{server_name} ended connection")
           close
-          next
+          break
         end
 
+        log_debug("Received #{message}")
         payload = deserialize_payload(message)
+        log_debug("Parsed #{payload}")
         next unless payload['type'] == 'publishEvent'
 
-        class_callback(payload['data'])
+        trigger_callback(instantiate_debounced_object(payload['data']))
       rescue IO::TimeoutError
-        # Ignored
+        # Ignored - normal flow of loop: check abort_signal (L48), get data (L56), timeout waiting for data (69)
       end
     rescue StandardError => e
       log_warn("Unable to listen for messages from #{server_name}: #{e.message}")
@@ -81,24 +86,24 @@ module Debounced
       @socket = nil
     end
 
-    def debounce_request(descriptor, event, timeout)
+    def build_request(descriptor, object, timeout)
       {
         type: 'debounceEvent',
         data: {
-          timeout: timeout,
-          descriptor: descriptor,
-          klass: event.class.name,
-          attributes: event_attributes(event)
+          timeout:,
+          descriptor:,
+          klass: object.class.name,
+          attributes: extract_attributes(object)
         }
       }
     end
 
-    def event_attributes(event)
-      if event.respond_to?(:attributes)
-        event.attributes
+    def extract_attributes(object)
+      if object.respond_to?(:attributes)
+        object.attributes
       else
-        event.instance_variables.each_with_object({}) do |var, hash|
-          hash[var.to_s.delete('@')] = event.instance_variable_get(var)
+        object.instance_variables.each_with_object({}) do |var, hash|
+          hash[var.to_s.delete('@')] = object.instance_variable_get(var)
         end
       end
     end
@@ -112,21 +117,21 @@ module Debounced
     end
 
     def serialize_payload(payload)
-      "#{ActiveSupport::JSON.encode(payload)}#{DELIMITER}" # inject EOM delimiter (form feed character)
+      "#{JSON.generate(payload)}#{DELIMITER}" # inject EOM delimiter (form feed character)
     end
 
     def deserialize_payload(payload)
-      ActiveSupport::JSON.decode(payload)
+      JSON.parse(payload)
     end
 
-    def object_callback(object)
-      object.send(Debounced.configuration.callback_method, args)
+    def trigger_callback(object)
+      object.send(Debounced.configuration.callback_method)
     end
 
-    def class_callback(data)
-      klass = data['klass'].constantize
-      data = data['attributes']
-      klass.send(Debounced.configuration.callback_method, data)
+    def instantiate_debounced_object(data)
+      klass = Object.const_get(data['klass'])
+      data = data['attributes'].transform_keys(&:to_sym)
+      klass.new(**data)
     end
 
     def socket_descriptor
@@ -134,40 +139,28 @@ module Debounced
     end
 
     def socket
-      @socket ||= UNIXSocket.new(socket_descriptor)
-                          .tap do |socket|
-        socket.timeout = @wait_timeout
+      @socket ||= begin
+        log_debug("Connecting to #{server_name} at #{socket_descriptor}")
+        UNIXSocket.new(socket_descriptor).tap { it.timeout = @wait_timeout }
       end
-    ###
-    # Errno::ENOENT is raised if the socket file does not exist.
-    # Errno::ECONNREFUSED is raised if the socket file exists but no process is listening on it.
     rescue Errno::ECONNREFUSED, Errno::ENOENT
+      ###
+      # Errno::ENOENT is raised if the socket file does not exist.
+      # Errno::ECONNREFUSED is raised if the socket file exists but no process is listening on it.
       log_debug("#{server_name} is not running")
       nil
     end
     
     def log_debug(message)
-      if defined?(Rails)
-        Rails.logger.debug { message }
-      else
-        puts "[DEBUG] #{message}" if ENV['DEBUG']
-      end
+      Debounced.configuration.logger.debug { message }
     end
     
     def log_info(message)
-      if defined?(Rails)
-        Rails.logger.info(message)
-      else
-        puts "[INFO] #{message}"
-      end
+      Debounced.configuration.logger.info(message)
     end
     
     def log_warn(message)
-      if defined?(Rails)
-        Rails.logger.warn(message)
-      else
-        puts "[WARNING] #{message}"
-      end
+      Debounced.configuration.logger.warn(message)
     end
   end
 end

data/lib/debounced/version.rb

@@ -1,3 +1,3 @@
 module Debounced
-  VERSION = "0.1.16"
+  VERSION = "0.1.17"
 end

data/lib/debounced.rb

@@ -1,6 +1,7 @@
-require "debounced/version"
-require "debounced/railtie" if defined?(Rails)
-require "debounced/service_proxy"
+require 'debounced/version'
+require 'debounced/railtie' if defined?(Rails)
+require 'debounced/service_proxy'
+require 'semantic_logger'
 
 module Debounced
   class Error < StandardError; end
@@ -16,12 +17,15 @@ module Debounced
   end
 
   class Configuration
-    attr_accessor :socket_descriptor, :wait_timeout, :callback_method
+    attr_accessor :socket_descriptor, :wait_timeout, :callback_method, :logger
 
     def initialize
       @socket_descriptor = ENV['DEBOUNCED_SOCKET'] || '/tmp/app.debounceEvents'
       @wait_timeout = ENV['DEBOUNCED_TIMEOUT']&.to_i || 3
       @callback_method = :publish
+      SemanticLogger.add_appender(file_name: 'debounced_proxy.log', formatter: :color)
+      SemanticLogger.default_level = ENV.fetch('LOG_LEVEL', 'info')
+      @logger = SemanticLogger['ServiceProxy']
     end
   end
 end

metadata

@@ -1,92 +1,77 @@
 --- !ruby/object:Gem::Specification
 name: debounced
 version: !ruby/object:Gem::Version
-  version: 0.1.16
+  version: 0.1.17
 platform: ruby
 authors:
 - Gary Passero
 bindir: bin
 cert_chain: []
-date: 2025-03-17 00:00:00.000000000 Z
+date: 2025-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 2.10.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 2.10.2
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: semantic_logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
+        version: 4.15.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 4.15.0
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.21'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.21'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: rubocop-rails
+  name: debug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.12'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.12'
-- !ruby/object:Gem::Dependency
-  name: rubocop-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+        version: '1.0'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: 1.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.4'
-description: A Ruby wrapper for a NodeJS server that uses the JavaScript micro event
-  loop to debounce events in Ruby applications
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: Leverage JavaScript micro-event loop to debounce events in Ruby applications
 email:
 - gary@flytedesk.com
 executables: []
@@ -97,8 +82,8 @@ files:
 - README.md
 - lib/debounced.rb
 - lib/debounced/abort_signal.rb
-- lib/debounced/javascript/debounce.mjs
 - lib/debounced/javascript/server.mjs
+- lib/debounced/javascript/service.mjs
 - lib/debounced/railtie.rb
 - lib/debounced/service_proxy.rb
 - lib/debounced/version.rb

data/lib/debounced/javascript/debounce.mjs

@@ -1,68 +0,0 @@
-import ipc from 'node-ipc';
-import fs from 'fs';
-
-const logLevel = process.env.LOG_LEVEL || 'info';
-
-export default class DebounceService {
-  constructor(socketDescriptor) {
-    this._socketDescriptor = socketDescriptor;
-    this._timers = {};
-    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.configureServer();
-    this.registerMessageTypes();
-  }
-
-  registerMessageTypes() {
-    ipc.server.on('debounceEvent', this.debounceEvent);
-    ipc.server.on('reset', this.reset);
-    ipc.server.on('error', this.handleError);
-  }
-
-  configureServer() {
-    // Remove the existing socket file if it exists
-    if (fs.existsSync(this._socketDescriptor)) {
-      console.log('DebounceEventService removing stale socket file ', this._socketDescriptor);
-      fs.unlinkSync(this._socketDescriptor);
-    }
-
-    ipc.config.delimiter = '\f'; // incoming messages are terminated by a form feed character
-    ipc.config.encoding = 'utf8';
-    ipc.config.silent = (logLevel !== 'debug');
-
-    ipc.serve(this._socketDescriptor);
-  }
-
-  listen() {
-    console.log('DebounceService listening on', this._socketDescriptor);
-    ipc.server.start();
-  }
-
-  publishEvent(descriptor, data) {
-    console.log(`Debounce period expired for ${descriptor}, publishing ${data.klass} event`);
-    ipc.server.broadcast("publishEvent", data);
-  }
-
-  debounceEvent({ descriptor, attributes, klass, timeout }) {
-    if (this._timers[descriptor]) {
-      clearTimeout(this._timers[descriptor]);
-    }
-
-    this._timers[descriptor] = setTimeout(() => {
-      delete this._timers[descriptor];
-      this.publishEvent(descriptor, { attributes, klass });
-    }, timeout * 1000);
-  }
-
-  reset() {
-    Object.values(this._timers).forEach(timerID => clearTimeout(timerID));
-    this._timers = {};
-  }
-
-  handleError(err) {
-    console.log('\n\n######\nERROR: ', err);
-  }
-}