selenium-webdriver 4.38.0 → 4.41.0

data/lib/selenium/webdriver/common/wait.rb

@@ -37,7 +37,8 @@ module Selenium
         @timeout  = opts.fetch(:timeout, DEFAULT_TIMEOUT)
         @interval = opts.fetch(:interval, DEFAULT_INTERVAL)
         @message  = opts[:message]
-        @ignored  = Array(opts[:ignore] || Error::NoSuchElementError)
+        @message_provider = opts[:message_provider]
+        @ignored = Array(opts[:ignore] || Error::NoSuchElementError)
       end
 
       #
@@ -64,6 +65,8 @@ module Selenium
 
         msg = if @message
                 @message.dup
+              elsif @message_provider
+                @message_provider.call
               else
                 "timed out after #{@timeout} seconds"
               end

data/lib/selenium/webdriver/common/websocket_connection.rb

@@ -24,7 +24,10 @@ module Selenium
     class WebSocketConnection
       CONNECTION_ERRORS = [
         Errno::ECONNRESET, # connection is aborted (browser process was killed)
-        Errno::EPIPE # broken pipe (browser process was killed)
+        Errno::EPIPE, # broken pipe (browser process was killed)
+        Errno::EBADF, # file descriptor already closed (double-close or GC)
+        IOError, # Ruby socket read/write after close
+        EOFError # socket reached EOF after remote closed cleanly
       ].freeze
 
       RESPONSE_WAIT_TIMEOUT = 30
@@ -35,6 +38,11 @@ module Selenium
       def initialize(url:)
         @callback_threads = ThreadGroup.new
 
+        @callbacks_mtx = Mutex.new
+        @messages_mtx = Mutex.new
+        @closing_mtx = Mutex.new
+
+        @closing = false
         @session_id = nil
         @url = url
 
@@ -43,9 +51,26 @@ module Selenium
       end
 
       def close
-        @callback_threads.list.each(&:exit)
-        @socket_thread.exit
-        socket.close
+        @closing_mtx.synchronize do
+          return if @closing
+
+          @closing = true
+        end
+
+        begin
+          socket.close
+        rescue *CONNECTION_ERRORS => e
+          WebDriver.logger.debug "WebSocket listener closed: #{e.class}: #{e.message}", id: :ws
+          # already closed
+        end
+
+        # Let threads unwind instead of calling exit
+        @socket_thread&.join(0.5)
+        @callback_threads.list.each do |thread|
+          thread.join(0.5)
+        rescue StandardError => e
+          WebDriver.logger.debug "Failed to join thread during close: #{e.class}: #{e.message}", id: :ws
+        end
       end
 
       def callbacks
@@ -53,62 +78,73 @@ module Selenium
       end
 
       def add_callback(event, &block)
-        callbacks[event] << block
-        block.object_id
+        @callbacks_mtx.synchronize do
+          callbacks[event] << block
+          block.object_id
+        end
       end
 
       def remove_callback(event, id)
-        return if callbacks[event].reject! { |callback| callback.object_id == id }
+        @callbacks_mtx.synchronize do
+          return if @closing
+
+          callbacks_for_event = callbacks[event]
+          return if callbacks_for_event.reject! { |cb| cb.object_id == id }
 
-        ids = callbacks[event]&.map(&:object_id)
-        raise Error::WebDriverError, "Callback with ID #{id} does not exist for event #{event}: #{ids}"
+          ids = callbacks_for_event.map(&:object_id)
+          raise Error::WebDriverError, "Callback with ID #{id} does not exist for event #{event}: #{ids}"
+        end
       end
 
       def send_cmd(**payload)
         id = next_id
         data = payload.merge(id: id)
-        WebDriver.logger.debug "WebSocket -> #{data}"[...MAX_LOG_MESSAGE_SIZE], id: :bidi
+        WebDriver.logger.debug "WebSocket -> #{data}"[...MAX_LOG_MESSAGE_SIZE], id: :ws
         data = JSON.generate(data)
         out_frame = WebSocket::Frame::Outgoing::Client.new(version: ws.version, data: data, type: 'text')
-        socket.write(out_frame.to_s)
 
-        wait.until { messages.delete(id) }
+        begin
+          socket.write(out_frame.to_s)
+        rescue *CONNECTION_ERRORS => e
+          raise e, "WebSocket is closed (#{e.class}: #{e.message})"
+        end
+
+        wait.until { @messages_mtx.synchronize { messages.delete(id) } }
       end
 
       private
 
-      # We should be thread-safe to use the hash without synchronization
-      # because its keys are WebSocket message identifiers and they should be
-      # unique within a devtools session.
       def messages
         @messages ||= {}
       end
 
       def process_handshake
         socket.print(ws.to_s)
-        ws << socket.readpartial(1024)
+        ws << socket.readpartial(1024) until ws.finished?
       end
 
       def attach_socket_listener
         Thread.new do
-          Thread.current.abort_on_exception = true
           Thread.current.report_on_exception = false
 
-          until socket.eof?
+          loop do
+            break if @closing
+
             incoming_frame << socket.readpartial(1024)
 
             while (frame = incoming_frame.next)
+              break if @closing
+
               message = process_frame(frame)
               next unless message['method']
 
-              params = message['params']
-              callbacks[message['method']].each do |callback|
-                @callback_threads.add(callback_thread(params, &callback))
+              @messages_mtx.synchronize { callbacks[message['method']].dup }.each do |callback|
+                @callback_threads.add(callback_thread(message['params'], &callback))
               end
             end
           end
-        rescue *CONNECTION_ERRORS
-          Thread.stop
+        rescue *CONNECTION_ERRORS, WebSocket::Error => e
+          WebDriver.logger.debug "WebSocket listener closed: #{e.class}: #{e.message}", id: :ws
         end
       end
 
@@ -122,27 +158,27 @@ module Selenium
         # Firefox will periodically fail on unparsable empty frame
         return {} if message.empty?
 
-        message = JSON.parse(message)
-        messages[message['id']] = message
-        WebDriver.logger.debug "WebSocket <- #{message}"[...MAX_LOG_MESSAGE_SIZE], id: :bidi
+        msg = JSON.parse(message)
+        @messages_mtx.synchronize { messages[msg['id']] = msg if msg.key?('id') }
 
-        message
+        WebDriver.logger.debug "WebSocket <- #{msg}"[...MAX_LOG_MESSAGE_SIZE], id: :ws
+        msg
       end
 
       def callback_thread(params)
         Thread.new do
-          Thread.current.abort_on_exception = true
-
-          # We might end up blocked forever when we have an error in event.
-          # For example, if network interception event raises error,
-          # the browser will keep waiting for the request to be proceeded
-          # before returning back to the original thread. In this case,
-          # we should at least print the error.
-          Thread.current.report_on_exception = true
+          Thread.current.abort_on_exception = false
+          Thread.current.report_on_exception = false
+          next if @closing
 
           yield params
-        rescue Error::WebDriverError, *CONNECTION_ERRORS
-          Thread.stop
+        rescue Error::WebDriverError, *CONNECTION_ERRORS => e
+          WebDriver.logger.debug "Callback aborted: #{e.class}: #{e.message}", id: :ws
+        rescue StandardError => e
+          next if @closing
+
+          bt = Array(e.backtrace).first(5).join("\n")
+          WebDriver.logger.error "Callback error: #{e.class}: #{e.message}\n#{bt}", id: :ws
         end
       end
 

data/lib/selenium/webdriver/common.rb

@@ -78,6 +78,7 @@ require 'selenium/webdriver/common/driver_extensions/has_addons'
 require 'selenium/webdriver/common/driver_extensions/has_bidi'
 require 'selenium/webdriver/common/driver_extensions/has_devtools'
 require 'selenium/webdriver/common/driver_extensions/has_file_downloads'
+require 'selenium/webdriver/common/driver_extensions/has_session_events'
 require 'selenium/webdriver/common/driver_extensions/has_authentication'
 require 'selenium/webdriver/common/driver_extensions/has_logs'
 require 'selenium/webdriver/common/driver_extensions/has_log_events'

data/lib/selenium/webdriver/devtools.rb

@@ -84,7 +84,7 @@ module Selenium
       def start_session(target_type:)
         targets = target.get_targets.dig('result', 'targetInfos')
         found_target = targets.find { |target| target['type'] == target_type }
-        raise Error::WebDriverError, "Target type '#{target_type}' not found" unless found_target
+        raise Error::NoSuchTargetError, "Target type '#{target_type}' not found" unless found_target
 
         session = target.attach_to_target(target_id: found_target['targetId'], flatten: true)
         @session_id = session.dig('result', 'sessionId')

data/lib/selenium/webdriver/edge/driver.rb

@@ -31,8 +31,9 @@ module Selenium
         include LocalDriver
 
         def initialize(options: nil, service: nil, url: nil, **)
-          caps, url = initialize_local_driver(options, service, url)
-          super(caps: caps, url: url, **)
+          initialize_local_driver(options, service, url) do |caps, driver_url|
+            super(caps: caps, url: driver_url, **)
+          end
         end
 
         def browser

data/lib/selenium/webdriver/edge/service.rb

@@ -25,6 +25,17 @@ module Selenium
         EXECUTABLE = 'msedgedriver'
         SHUTDOWN_SUPPORTED = true
         DRIVER_PATH_ENV_KEY = 'SE_EDGEDRIVER'
+
+        def initialize(args: nil, **)
+          if ENV.key?('SE_DEBUG')
+            args = Array(args.dup)
+            warn_driver_log_override if args.reject! { |arg| arg.include?('log-level') || arg.include?('silent') }
+            args << '--verbose'
+          end
+
+          super
+        end
+
         def log
           return @log unless @log.is_a? String
 

data/lib/selenium/webdriver/firefox/driver.rb

@@ -37,8 +37,9 @@ module Selenium
         include LocalDriver
 
         def initialize(options: nil, service: nil, url: nil, **)
-          caps, url = initialize_local_driver(options, service, url)
-          super(caps: caps, url: url, **)
+          initialize_local_driver(options, service, url) do |caps, driver_url|
+            super(caps: caps, url: driver_url, **)
+          end
         end
 
         def browser

data/lib/selenium/webdriver/firefox/service.rb

@@ -26,14 +26,33 @@ module Selenium
         SHUTDOWN_SUPPORTED = false
         DRIVER_PATH_ENV_KEY = 'SE_GECKODRIVER'
 
-        def initialize(path: nil, port: nil, log: nil, args: nil)
-          args ||= []
+        def initialize(args: nil, **)
+          args = Array(args.dup)
           unless args.any? { |arg| arg.include?('--connect-existing') || arg.include?('--websocket-port') }
             args << '--websocket-port'
             args << '0'
           end
+
+          if ENV.key?('SE_DEBUG')
+            remove_log_args(args)
+            args << '-v'
+          end
+
           super
         end
+
+        private
+
+        def remove_log_args(args)
+          if (index = args.index('--log'))
+            args.delete_at(index) # delete '--log'
+            args.delete_at(index) if args[index] && !args[index].start_with?('-') # delete value if present
+            warn_driver_log_override
+          elsif (index = args.index { |arg| arg.start_with?('--log=') })
+            args.delete_at(index)
+            warn_driver_log_override
+          end
+        end
       end # Service
     end # Firefox
   end # WebDriver

data/lib/selenium/webdriver/ie/driver.rb

@@ -32,8 +32,9 @@ module Selenium
         include LocalDriver
 
         def initialize(options: nil, service: nil, url: nil, **)
-          caps, url = initialize_local_driver(options, service, url)
-          super(caps: caps, url: url, **)
+          initialize_local_driver(options, service, url) do |caps, driver_url|
+            super(caps: caps, url: driver_url, **)
+          end
         end
 
         def browser

data/lib/selenium/webdriver/ie/service.rb

@@ -25,6 +25,16 @@ module Selenium
         EXECUTABLE = 'IEDriverServer'
         SHUTDOWN_SUPPORTED = true
         DRIVER_PATH_ENV_KEY = 'SE_IEDRIVER'
+
+        def initialize(args: nil, **)
+          if ENV.key?('SE_DEBUG')
+            args = Array(args.dup)
+            warn_driver_log_override if args.reject! { |arg| arg.include?('log-level') || arg.include?('silent') }
+            args << '--log-level=DEBUG'
+          end
+
+          super
+        end
       end # Server
     end # IE
   end # WebDriver

data/lib/selenium/webdriver/remote/bidi_bridge.rb

@@ -46,9 +46,11 @@ module Selenium
         end
 
         def quit
-          super
-        ensure
           bidi.close
+        rescue *QUIT_ERRORS
+          nil
+        ensure
+          super
         end
 
         def close

data/lib/selenium/webdriver/remote/bridge.rb

@@ -206,12 +206,20 @@ module Selenium
           switch_to_frame nil
         end
 
-        QUIT_ERRORS = [IOError].freeze
+        QUIT_ERRORS = [IOError, EOFError, WebSocket::Error].freeze
 
         def quit
-          execute :delete_session
-          http.close
-        rescue *QUIT_ERRORS
+          begin
+            execute :delete_session
+          rescue *QUIT_ERRORS => e
+            WebDriver.logger.debug "delete_session failed during quit: #{e.class}: #{e.message}", id: :quit
+          ensure
+            begin
+              http.close
+            rescue *QUIT_ERRORS => e
+              WebDriver.logger.debug "http.close failed during quit: #{e.class}: #{e.message}", id: :quit
+            end
+          end
           nil
         end
 

data/lib/selenium/webdriver/remote/driver.rb

@@ -29,6 +29,7 @@ module Selenium
         include DriverExtensions::UploadsFiles
         include DriverExtensions::HasSessionId
         include DriverExtensions::HasFileDownloads
+        include DriverExtensions::HasSessionEvents
 
         def initialize(capabilities: nil, options: nil, service: nil, url: nil, **)
           raise ArgumentError, "Can not set :service object on #{self.class}" if service

data/lib/selenium/webdriver/remote/features.rb

@@ -25,7 +25,8 @@ module Selenium
           upload_file: [:post, 'session/:session_id/se/file'],
           get_downloadable_files: [:get, 'session/:session_id/se/files'],
           download_file: [:post, 'session/:session_id/se/files'],
-          delete_downloadable_files: [:delete, 'session/:session_id/se/files']
+          delete_downloadable_files: [:delete, 'session/:session_id/se/files'],
+          fire_session_event: [:post, 'session/:session_id/se/event']
         }.freeze
 
         def add_commands(commands)
@@ -69,6 +70,30 @@ module Selenium
         def delete_downloadable_files
           execute :delete_downloadable_files
         end
+
+        #
+        # Fires a custom session event to the remote server event bus.
+        # This allows test code to trigger server-side utilities that subscribe to
+        # the event bus.
+        #
+        # @param [String] event_type The type of event (e.g., "test:failed", "log:collect")
+        # @param [Hash] payload Optional data to include with the event
+        # @return [Hash] Response data including success status, event type, and timestamp
+        #
+        # @example Fire a simple event
+        #   driver.fire_session_event("test:started")
+        #
+        # @example Fire an event with payload
+        #   driver.fire_session_event("test:failed", {
+        #     testName: "LoginTest",
+        #     error: "Element not found"
+        #   })
+        #
+        def fire_session_event(event_type, payload = nil)
+          params = {eventType: event_type}
+          params[:payload] = payload if payload
+          execute :fire_session_event, {}, params
+        end
       end
     end # Remote
   end # WebDriver

data/lib/selenium/webdriver/remote/http/common.rb

@@ -28,6 +28,7 @@ module Selenium
             'Accept' => CONTENT_TYPE,
             'Content-Type' => "#{CONTENT_TYPE}; charset=UTF-8"
           }.freeze
+          BINARY_ENCODINGS = [Encoding::BINARY, Encoding::ASCII_8BIT].freeze
 
           class << self
             attr_accessor :extra_headers
@@ -55,6 +56,7 @@ module Selenium
             headers['Cache-Control'] = 'no-cache' if verb == :get
 
             if command_hash
+              command_hash              = ensure_utf8_encoding(command_hash)
               payload                   = JSON.generate(command_hash)
               headers['Content-Length'] = payload.bytesize.to_s if %i[post put].include?(verb)
 
@@ -91,6 +93,36 @@ module Selenium
             raise NotImplementedError, 'subclass responsibility'
           end
 
+          def ensure_utf8_encoding(obj)
+            case obj
+            when String
+              encode_string_to_utf8(obj)
+            when Array
+              obj.map { |item| ensure_utf8_encoding(item) }
+            when Hash
+              obj.each_with_object({}) do |(key, value), result|
+                result[ensure_utf8_encoding(key)] = ensure_utf8_encoding(value)
+              end
+            else
+              obj
+            end
+          end
+
+          def encode_string_to_utf8(str)
+            return str if str.encoding == Encoding::UTF_8 && str.valid_encoding?
+
+            if BINARY_ENCODINGS.include?(str.encoding)
+              result = str.dup.force_encoding(Encoding::UTF_8)
+              return result if result.valid_encoding?
+            end
+
+            str.encode(Encoding::UTF_8)
+          rescue EncodingError => e
+            raise Error::WebDriverError,
+                  "Unable to encode string to UTF-8: #{e.message}. " \
+                  "String encoding: #{str.encoding}, content: #{str.inspect}"
+          end
+
           def create_response(code, body, content_type)
             code = code.to_i
             body = body.to_s.strip

data/lib/selenium/webdriver/safari/driver.rb

@@ -32,8 +32,9 @@ module Selenium
         include LocalDriver
 
         def initialize(options: nil, service: nil, url: nil, **)
-          caps, url = initialize_local_driver(options, service, url)
-          super(caps: caps, url: url, **)
+          initialize_local_driver(options, service, url) do |caps, driver_url|
+            super(caps: caps, url: driver_url, **)
+          end
         end
 
         def browser

data/lib/selenium/webdriver/support/block_event_listener.rb

@@ -25,9 +25,13 @@ module Selenium
           @callback = callback
         end
 
-        def method_missing(meth, *) # rubocop:disable Style/MissingRespondToMissing
+        def method_missing(meth, *)
           @callback.call(meth, *)
         end
+
+        def respond_to_missing?(_meth, _include_private = false)
+          true
+        end
       end # BlockEventListener
     end # Support
   end # WebDriver

data/lib/selenium/webdriver/support/color.rb

@@ -72,26 +72,26 @@ module Selenium
           end
         end
 
-        def self.from_hsl(h, s, l, a) # rubocop:disable Naming/MethodParameterName
-          h = Float(h) / 360
-          s = Float(s) / 100
-          l = Float(l) / 100
-          a = Float(a || 1)
-
-          if s.zero?
-            r = l
+        def self.from_hsl(hue, sat, light, alpha)
+          hue = Float(hue) / 360
+          sat = Float(sat) / 100
+          light = Float(light) / 100
+          alpha = Float(alpha || 1)
+
+          if sat.zero?
+            r = light
             g = r
             b = r
           else
-            luminocity2 = l < 0.5 ? l * (s + 1) : l + s - (l * s)
-            luminocity1 = (l * 2) - luminocity2
+            luminocity2 = light < 0.5 ? light * (sat + 1) : light + sat - (light * sat)
+            luminocity1 = (light * 2) - luminocity2
 
-            r = hue_to_rgb(luminocity1, luminocity2, h + (1.0 / 3.0))
-            g = hue_to_rgb(luminocity1, luminocity2, h)
-            b = hue_to_rgb(luminocity1, luminocity2, h - (1.0 / 3.0))
+            r = hue_to_rgb(luminocity1, luminocity2, hue + (1.0 / 3.0))
+            g = hue_to_rgb(luminocity1, luminocity2, hue)
+            b = hue_to_rgb(luminocity1, luminocity2, hue - (1.0 / 3.0))
           end
 
-          new (r * 255).round, (g * 255).round, (b * 255).round, a
+          new (r * 255).round, (g * 255).round, (b * 255).round, alpha
         end
 
         def self.hue_to_rgb(lum1, lum2, hue)

data/lib/selenium/webdriver/support/event_firing_bridge.rb

@@ -120,9 +120,13 @@ module Selenium
           returned
         end
 
-        def method_missing(meth, ...) # rubocop:disable Style/MissingRespondToMissing
+        def method_missing(meth, ...)
           @delegate.__send__(meth, ...)
         end
+
+        def respond_to_missing?(meth, include_private = false)
+          @delegate.respond_to?(meth, include_private) || super
+        end
       end # EventFiringBridge
     end # Support
   end # WebDriver

data/lib/selenium/webdriver/version.rb

@@ -19,6 +19,6 @@
 
 module Selenium
   module WebDriver
-    VERSION = '4.38.0'
+    VERSION = '4.41.0'
   end # WebDriver
 end # Selenium

data/lib/selenium/webdriver.rb

@@ -95,8 +95,13 @@ module Selenium
     #
 
     def self.logger(**)
-      level = $DEBUG || ENV.key?('DEBUG') ? :debug : :info
-      @logger ||= WebDriver::Logger.new('Selenium', default_level: level, **)
+      level = $DEBUG || ENV.key?('DEBUG') || ENV.key?('SE_DEBUG') ? :debug : :info
+      @logger ||= WebDriver::Logger.new('Selenium', default_level: level, **).tap do |logger|
+        if ENV.key?('SE_DEBUG')
+          logger.debug!
+          logger.stderr!
+        end
+      end
     end
   end # WebDriver
 end # Selenium

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: selenium-webdriver
 version: !ruby/object:Gem::Version
-  version: 4.38.0
+  version: 4.41.0
 platform: ruby
 authors:
 - Alex Rodionov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-25 00:00:00.000000000 Z
+date: 2026-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -333,6 +333,7 @@ files:
 - lib/selenium/webdriver/common/driver_extensions/has_network_interception.rb
 - lib/selenium/webdriver/common/driver_extensions/has_permissions.rb
 - lib/selenium/webdriver/common/driver_extensions/has_pinned_scripts.rb
+- lib/selenium/webdriver/common/driver_extensions/has_session_events.rb
 - lib/selenium/webdriver/common/driver_extensions/has_session_id.rb
 - lib/selenium/webdriver/common/driver_extensions/prints_page.rb
 - lib/selenium/webdriver/common/driver_extensions/uploads_files.rb