debounced 1.0.1 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c04a25987dd47d790a0b44b4529025611c441fed620a19d9346cf9823b14e82b
-  data.tar.gz: 0e01be8b3bfe43c432eee4daee54cfbca72515039fcd07a9ee8cb2f1605a054b
+  metadata.gz: f90306d666ec22b89d230a9e57a589d7e3c6f6cc4344f4107958e018d3fc8dab
+  data.tar.gz: 0d035ebc14a9e4737ce9031484d56ecf4d46ffdf9dc97232f5d6f933cd971128
 SHA512:
-  metadata.gz: cf5c0932ded695167ec91dfe1d5bf808bb79a37d394edf1e005511803a4e7347ee9658df2ae6c42c2fb239444f0e19ac70dcf342827aac5835e3d991994f1b39
-  data.tar.gz: 010a2121814282d3e8e2254339953fd78397bd545ab876b5a81ad6a88b08e3febd628b03e2e9d72f6b80f689770804629739c86af95ec542acad34e06e1b9bd4
+  metadata.gz: 798c7ff5e42b9b610684550c5a05081d430399cd5bb138eacfd7fd92d1a9fade82a22597df5b7e5c561129522b8177fa3f948498d71b2728575d6d954fd0492e
+  data.tar.gz: 1b64a24b034f701d913b1d7ac0cfa7192e421028378c17a7bf51c2792e9c52facda9a0c5038c289d95f7a7959cece9dedfa77b6dae2f149baef06294bd1dcf27

data/CHANGELOG.md

@@ -5,11 +5,21 @@ 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).
 
-## [0.1.0] - 2025-03-16
+## [1.0.0] - 2025-03-21
 
-### Added
 - Initial release
 - Core functionality extracted from supply-side-platform
 - Ruby wrapper for Node.js event debouncing service
 - Configuration options for socket descriptor
-- Rails integration via Railtie
+
+## [1.0.1] - 2025-03-21
+
+- Removed dependency on 'json/add/core' that seemed to interfere with Rails JSON serialization
+
+## [1.0.2] - 2025-03-26
+
+- Fixed bug where Ruby (proxy) would allow messages to be sent to Javascript (server), even if the Ruby (proxy) was not listening for messages from Javascript (server)
+
+## [1.0.3] - 2025-03-26
+
+- Avoid using a trace log level, which is not supported by the default Rails loggers.

data/lib/debounced/callback.rb

@@ -40,6 +40,7 @@ module Debounced
     end
 
     def call
+      Debounced.configuration.logger.debug("Invoking callback #{method_name}")
       klass = Object.const_get(class_name)
       if klass.respond_to?(method_name)
         klass.send(method_name, *args, **kwargs)
@@ -47,7 +48,9 @@ module Debounced
         instance = klass.new(*args, **kwargs)
         instance.send(method_name)
       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
-
   end
 end

data/lib/debounced/javascript/service.mjs

@@ -1,6 +1,11 @@
 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;
@@ -11,6 +16,7 @@ export default class DebounceService {
     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.onClientDisconnected = this.onClientDisconnected.bind(this);
     this.onConnectionError = this.onConnectionError.bind(this);
@@ -19,13 +25,13 @@ export default class DebounceService {
   }
 
   onConnectionError(err) {
-    console.log('DebounceService client connection error');
+    log('DebounceService client connection error');
     this._client = null
     this.handleError(err);
   }
 
   onClientDisconnected() {
-    console.log('DebounceService client disconnected');
+    log('DebounceService client disconnected');
     this._client = null
   }
 
@@ -37,27 +43,28 @@ export default class DebounceService {
       } else if (object.type === 'reset') {
         this.reset();
       } else {
-        console.log('DebounceService unknown message', message);
+        log('DebounceService unknown message', message);
       }
     } catch (e) {
-      console.log('unable to parse message', e);
+      log('unable to parse message', e);
     }
   }
 
   onClientConnected(socket) {
     if (this._client) {
-      console.log('DebounceService rejecting connection: already has a client');
-      socket.end();
+      log('DebounceService rejecting connection: client already connected');
+      this.sendMessage(socket, JSON.stringify({ type: 'rejectClient'}));
+      socket.destroy();
       return;
     }
 
-    console.log('DebounceService client connected');
+    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());
+      log('DebounceService data received', data.toString());
       connectionBuffer += data.toString();
       const messages = connectionBuffer.split('\f');
       connectionBuffer = ''
@@ -73,48 +80,58 @@ export default class DebounceService {
     this.server.on('error', this.handleError);
   }
 
-  listen() {
-    // Remove the existing socket file if it exists
+  cleanupDescriptor() {
     if (fs.existsSync(this._socketDescriptor)) {
-      console.log('DebounceEventService removing stale socket file ', this._socketDescriptor);
+      log('DebounceEventService removing stale socket file ', this._socketDescriptor);
       fs.unlinkSync(this._socketDescriptor);
     }
+  }
+
+  listen() {
+    // Remove the existing socket file if it exists
+    this.cleanupDescriptor()
 
     process.on('exit', (code) => {
-      console.log(`Process exiting with code: ${code}`);
+      log(`Process exiting with code: ${code}`);
       this.server.close();
+      this.cleanupDescriptor()
     });
 
     process.on('SIGTERM', () => {
-      console.log('Process received SIGTERM');
+      log('Process received SIGTERM');
       this.server.close();
+      this.cleanupDescriptor()
       process.exit(0);
     });
 
     process.on('SIGINT', () => {
-      console.log('Process received SIGINT');
+      log('Process received SIGINT');
       this.server.close();
+      this.cleanupDescriptor()
       process.exit(0);
     });
 
     this.server.listen(this._socketDescriptor, () => {
-      console.log('DebounceService listening on', this._socketDescriptor);
+      log('DebounceService listening on', this._socketDescriptor);
     });
   }
 
+  sendMessage(socket, message) {
+    try {
+      socket.write(message);
+      socket.write("\f");
+    } catch (err) {
+      this.handleError(err);
+    }
+  }
+
   publishEvent(descriptor, callback) {
-    console.log(`Debounce period expired for ${descriptor}`);
+    log(`Debounce period expired for ${descriptor} - sending to client`);
     const message = JSON.stringify({
       type: 'publishEvent',
       callback: callback
     });
-
-    try {
-      this._client.write(message);
-      this._client.write("\f");
-    } catch (err) {
-      this.handleError(err);
-    }
+    this.sendMessage(this._client, message);
   }
 
   debounceEvent({ descriptor, timeout, callback }) {
@@ -122,7 +139,7 @@ export default class DebounceService {
       clearTimeout(this._timers[descriptor]);
     }
 
-    console.log("Debouncing", descriptor);
+    log("Debouncing", descriptor);
     this._timers[descriptor] = setTimeout(() => {
       delete this._timers[descriptor];
       this.publishEvent(descriptor, callback);
@@ -135,6 +152,6 @@ export default class DebounceService {
   }
 
   handleError(err) {
-    console.log('\n\n######\nERROR: ', err);
+    log('\n\n######\nERROR: ', err);
   }
 }

data/lib/debounced/no_server_error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module Debounced
+  class NoServerError < StandardError
+  end
+end

data/lib/debounced/service_proxy.rb

@@ -10,10 +10,17 @@ module Debounced
   class ServiceProxy
     DELIMITER = "\f".freeze
 
+    attr_reader :logger, :wait_timeout, :listening
+
     def initialize
       @wait_timeout = Debounced.configuration.wait_timeout
+      @logger = Debounced.configuration.logger
+      @listening = false
+      @mutex = Mutex.new
     end
 
+    ###
+    # @param [Concurrent::AtomicBoolean] abort_signal set to true to stop listening for messages
     def listen(abort_signal = nil)
       Thread.new do
         receive(abort_signal)
@@ -22,58 +29,61 @@ module Debounced
 
     ###
     # Send message to server to reset its state. Useful for automated testing.
-    def reset
+    def reset_server
       if socket.nil?
-        log_debug("No connection to #{server_name}; unable to reset server.")
+        logger.warn("No connection to #{server_name}; unable to reset server.")
       else
-        log_debug("Resetting #{server_name}")
+        logger_trace { "Resetting #{server_name}" }
         transmit({ type: 'reset' })
       end
     end
 
     def debounce_activity(activity_descriptor, timeout, callback)
-      if socket.nil?
-        log_debug("No connection to #{server_name}; skipping debounce step.")
-        callback.call
-      else
-        log_debug("Debouncing #{activity_descriptor} to #{server_name}")
-        transmit(build_request(activity_descriptor, timeout, callback))
+      SemanticLogger.tagged("send") do
+        if !listening || socket.nil?
+          logger.debug { "No connection to #{server_name}; skipping debounce step." }
+          callback.call
+        else
+          logger_trace { "Sending #{activity_descriptor} to #{server_name}" }
+          transmit(build_request(activity_descriptor, timeout, callback))
+        end
       end
     end
 
+    ###
+    # @param [Concurrent::AtomicBoolean] abort_signal set to true to stop listening for messages
     def receive(abort_signal = nil)
-      log_debug("Listening for messages from #{server_name}...")
+      @abort_signal = abort_signal || Concurrent::AtomicBoolean.new
+      SemanticLogger.tagged("receive") do
+        logger.info { "Listening for messages from #{server_name}..." }
 
-      loop do
-        break if abort_signal&.set?
+        loop do
+          @listening = true
+          break if @abort_signal.true?
 
-        if socket.nil?
-          log_debug("Waiting for #{server_name} to start...")
-          sleep(@wait_timeout)
-          next
-        end
+          message = receive_message_from_server
+          next unless message
 
-        log_debug("Waiting for data from #{server_name}...")
-        message = socket.gets(DELIMITER, chomp: true)
-        if message.nil?
-          log_info("Server #{server_name} ended connection")
-          close
-          break
-        end
+          payload = deserialize_message(message)
+          raise SocketConflictError if payload['type'] == 'rejectClient'
 
-        log_debug("Received #{message}")
-        payload = deserialize_payload(message)
-        log_debug("Parsed #{payload}")
-        next unless payload['type'] == 'publishEvent'
+          instantiate_callback(payload['callback']).call
+        rescue Debounced::NoServerError => e
+          logger.debug e.message
+          sleep wait_timeout
+        end
 
-        instantiate_callback(payload['callback']).call
-      rescue IO::TimeoutError
-        # Ignored - normal flow of loop: check abort_signal (L48), get data (L56), timeout waiting for data (69)
+        close
       end
-    rescue StandardError => e
-      log_warn("Unable to listen for messages from #{server_name}: #{e.message}")
-      log_warn(e.backtrace.join("\n"))
+    rescue SocketConflictError, StandardError => e
+      logger.warn("Unable to listen for messages from #{server_name}: #{e.message}")
+      logger.warn(e.backtrace.join("\n"))
     ensure
+      @listening = false
+    end
+
+    def stop
+      @abort_signal.make_true
     end
 
     private
@@ -81,11 +91,30 @@ module Debounced
     def close
       return unless @socket
 
-      log_info("Closing connection to #{server_name}")
+      logger.debug("Closing connection to #{server_name}")
       @socket.close
       @socket = nil
     end
 
+    def receive_message_from_server
+      raise NoServerError, "#{server_name} at #{socket_descriptor} not running" if socket.nil?
+
+      logger_trace { "Waiting for data from #{server_name}..." }
+      message = socket.gets(DELIMITER, chomp: true)
+      unless message
+        close
+        sleep wait_timeout
+      end
+      message
+    rescue IO::TimeoutError
+      logger_trace { "Timeout waiting for data" }
+      sleep wait_timeout
+      nil
+    rescue Errno::EPIPE, IOError, Errno::ECONNRESET
+      close
+      raise NoServerError, "#{server_name} at #{socket_descriptor} not running"
+    end
+
     def build_request(descriptor, timeout, callback)
       {
         type: 'debounceEvent',
@@ -97,20 +126,21 @@ module Debounced
       }
     end
 
-    def transmit(request)
-      socket.send serialize_payload(request), 0
+    def transmit(message)
+      socket.send serialize_message(message), 0
     end
 
     def server_name
       'DebounceEventServer'
     end
 
-    def serialize_payload(payload)
-      "#{JSON.generate(payload)}#{DELIMITER}" # inject EOM delimiter (form feed character)
+    def serialize_message(message)
+      "#{JSON.generate(message)}#{DELIMITER}" # inject EOM delimiter (form feed character)
     end
 
-    def deserialize_payload(payload)
-      JSON.parse(payload)
+    def deserialize_message(message)
+      logger_trace { "Deserializing #{message}" }
+      JSON.parse(message)
     end
 
     def instantiate_callback(data)
@@ -122,28 +152,22 @@ module Debounced
     end
 
     def socket
-      @socket ||= begin
-        log_debug("Connecting to #{server_name} at #{socket_descriptor}")
-        UNIXSocket.new(socket_descriptor).tap { |s| s.timeout = @wait_timeout }
+      @mutex.synchronize do
+        return @socket if @socket
+
+        logger_trace { "Connecting to #{server_name} at #{socket_descriptor}" }
+        @socket = UNIXSocket.new(socket_descriptor).tap { |s| s.timeout = wait_timeout }
       end
     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)
-      Debounced.configuration.logger.debug { message }
-    end
-    
-    def log_info(message)
-      Debounced.configuration.logger.info(message)
-    end
-    
-    def log_warn(message)
-      Debounced.configuration.logger.warn(message)
+
+    def logger_trace(&block)
+      logger.debug(&block) if Debounced.configuration.enable_trace_logging
     end
+
   end
 end

data/lib/debounced/socket_conflict_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module Debounced
+  ###
+  # When the given socket is being used by another Ruby process, this error is raised.
+  class SocketConflictError < StandardError
+  end
+end

data/lib/debounced/version.rb

@@ -1,3 +1,3 @@
 module Debounced
-  VERSION = "1.0.1"
+  VERSION = "1.0.3"
 end

data/lib/debounced.rb

@@ -1,5 +1,7 @@
 require 'debounced/version'
 require 'debounced/railtie' if defined?(Rails)
+require 'debounced/no_server_error'
+require 'debounced/socket_conflict_error'
 require 'debounced/service_proxy'
 require 'debounced/callback'
 require 'semantic_logger'
@@ -18,7 +20,7 @@ module Debounced
   end
 
   class Configuration
-    attr_accessor :socket_descriptor, :wait_timeout, :logger
+    attr_accessor :socket_descriptor, :wait_timeout, :logger, :enable_trace_logging
 
     def initialize
       @socket_descriptor = ENV['DEBOUNCED_SOCKET'] || '/tmp/app.debounceEvents'
@@ -26,6 +28,7 @@ module Debounced
       SemanticLogger.add_appender(file_name: 'debounced_proxy.log', formatter: :color)
       SemanticLogger.default_level = ENV.fetch('LOG_LEVEL', 'info')
       @logger = SemanticLogger['ServiceProxy']
+      @enable_trace_logging = ENV['TRACE_LOGGING'] == 'true'
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: debounced
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.3
 platform: ruby
 authors:
 - Gary Passero
 bindir: bin
 cert_chain: []
-date: 2025-03-22 00:00:00.000000000 Z
+date: 2025-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -37,6 +37,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 4.15.0
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -81,12 +95,13 @@ files:
 - CHANGELOG.md
 - README.md
 - lib/debounced.rb
-- lib/debounced/abort_signal.rb
 - lib/debounced/callback.rb
 - lib/debounced/javascript/server.mjs
 - lib/debounced/javascript/service.mjs
+- lib/debounced/no_server_error.rb
 - lib/debounced/railtie.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

data/lib/debounced/abort_signal.rb

@@ -1,23 +0,0 @@
-module Debounced
-  ###
-  # Allow an abort signal to be passed to blocking call for graceful shutdown.
-  #
-  # Inspired by the AbortController in the DOM, but made for Ruby
-  # @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
-  #
-  # For notes about thread safety of this approach,
-  # @see https://stackoverflow.com/questions/9620886/is-it-safe-to-set-the-boolean-value-in-thread-from-another-one
-  class AbortSignal
-    def initialize
-      @abort = false
-    end
-
-    def abort
-      @abort = true
-    end
-
-    def set?
-      @abort
-    end
-  end
-end