From: "ioquatix (Samuel Williams)" Date: 2022-10-28T01:06:44+00:00 Subject: [ruby-core:110526] [Ruby master Feature#19078] Introduce `Fiber#storage` for inheritable fiber-scoped variables. Issue #19078 has been updated by ioquatix (Samuel Williams). > Often times, this is done to avoid holding a reference to the object in the thread, effectively making it immortal. I think the correct way to make opaque per-instance keys is something like this: ```ruby class ConnectionPool def initialize @connection_key = Object.new @count_key = Object.new end def checkout(options = {}) if connection = ::Fiber[@connection_key] ::Fiber[@count_key] += 1 else connection = ::Fiber[@connection_key] = @available.pop(options[:timeout] || @timeout) ::Fiber[@count_key] = 1 end return connection end end ``` I would say the above implementation is invalid, because inheriting the count and connection is likely to cause buggy behaviour, however the key point is, using `Object.new` for opaque keys should be totally fine. ---------------------------------------- Feature #19078: Introduce `Fiber#storage` for inheritable fiber-scoped variables. https://bugs.ruby-lang.org/issues/19078#change-99851 * Author: ioquatix (Samuel Williams) * Status: Open * Priority: Normal * Assignee: ioquatix (Samuel Williams) ---------------------------------------- Pull Request: https://github.com/ruby/ruby/pull/6612 This is an evolution of the previous ideas: - https://bugs.ruby-lang.org/issues/19058 - https://bugs.ruby-lang.org/issues/19062 This PR introduces fiber scoped variables, and is a solution for problems like . The main interface is: ```ruby Fiber[key] = value Fiber[key] # => value ``` The variables are scoped (local to) a fiber and inherited into child fibers and threads. ```ruby Fiber[:request_id] = SecureRandom.hex(16) Fiber.new do p Fiber[:request_id] # prints the above request id end ``` The fiber scoped variables are stored and can be accessed: ```ruby Fiber.current.storage # => returns a Hash (copy) of the internal storage. Fiber.current.storage= # => assigns a Hash (copy) to the internal storage. ``` Fiber itself has one new keyword argument: ``` Fiber.new(..., storage: hash, false, undef, nil) ``` This can control how the fiber variables are setup in a child context. To minimise the performance overhead of some of the implementation choices, we are also simultaneously implementing . ## Examples ### Request loop ```ruby Thread.new do while request = queue.pop Fiber.new(storage: {id: SecureRandom.hex(16)}) do handle_request.call(request) end end end ``` OR ```ruby Thread.new do while request = queue.pop Fiber.current.storage = {id: SecureRandom.hex(16)} handle_request.call(request) end end ``` -- https://bugs.ruby-lang.org/ Unsubscribe: