Issue #19078 has been updated by Dan0042 (Daniel DeLorme).
Maybe I'm too late here, but I have some thoughts/concerns about this.
First I should say I totally agree with the general idea. We need some way to inherit
"context state".
So far I've seen 2 use cases described.
1 - store a request_id or correlation_id, for logging purposes (or even the full request
object)
2 - store a connection (typically database) that can't be used at the same time by
another thread/fiber
It would be nice if we had 1-2 other use cases; that would allow to evaluate this design
from more angles.
We already have per-thread-but-actually-fiber storage, and a really-per-thread storage,
and this is adding a third type. What about when we want per-ractor storage... a fourth
type? Per-ractor inheritable storage... a fifth type? Rather than fragmenting storages I
would prefer to unify them. Maybe it's a crazy idea, but what if we set
fiber-inheritable values via `Thread.current.store(k, v, level: Fiber, inherit: true)` and
read them via `Thread.current[k]` ? For writing it's a somewhat complex/advanced
interface, but choosing which storage to use is a complex/advanced question anyway. And
when reading a value I think we typically don't care about which storage it is in; it
would be easier to have a single point of access.
When should a value be inherited? For usecase#1 (request_id), it seems to be all the time.
But for usecase#2 (connection) I think it varies. If you have a sub-fiber that does its
own requests to the DB, you don't want to inherit the connection. But if it's an
iterator fiber you do want to inherit the connection. So it depends on what
"kind" of fiber, how it is used. Actually, for an iterator fiber, you'd
probably want to inherit all state, even if it wasn't explicitly specified as
inheritable. So maybe something like `Fiber.new(inherit: true)` would be better for that
case.
What about when transfering control from one fiber to another?
```ruby
producer = Fiber.new{loop{
puts "on behalf of #{Thread.current[:request_id] || '?'}"
puts "producing #{v=rand}"
Fiber.yield(v)
}}
Thread.current[:request_id] = SecureRandom.hex(16)
producer.resume #=> random value
```
In the code above we could argue that the producer should "inherit" the
request_id via resume.
----------------------------------------
Feature #19078: Introduce `Fiber#storage` for inheritable fiber-scoped variables.
https://bugs.ruby-lang.org/issues/19078#change-100357
* 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
<https://github.com/ioquatix/ioquatix/discussions/17>.
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 <https://bugs.ruby-lang.org/issues/19077>.
## 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/