async 2.34.0 → 2.35.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05c05a5ba6d2dc436a12de9ff3cb562b3376892fd8c6615be8c4eb654d570fef
-  data.tar.gz: 2cb04cbecc3237b4476e5f42e4e130e8116ea10890c1b766140b238451c13f81
+  metadata.gz: ad14103d1146e967a38187e2d6d3d64b745b50f2f833b164c151ef53d270673e
+  data.tar.gz: b34db7f89b4054ed33dfbd22d979060b90d939180cf3014c4aa7a5b8c3f070eb
 SHA512:
-  metadata.gz: 16d4488b9d5fa9702bba6fead00c9c772402f792817daba79596cdf573e9f7b111ab77b85166d9b7b93c92babd9a717bf8fe11aa56ae67beded351fda99eaa7b
-  data.tar.gz: 289f3a854fcda83b35e92a1ebc14425722fdc856f8dfaa60e29f630ba79b3d72269816f7f01f940aa8926685701cd5ef1ba285a0576f91354107083cfaf96905
+  metadata.gz: 9b73a930aa37a5cb7695ca5deb66e181d80bd1b1157fbcbf711f6ff2f288c8b1294f05e32e02b68289608b1948315509c66bc541250cd14a19ed40461e283e99
+  data.tar.gz: 82cef6a6f824e38cf4cdd24a0a6447394e5c8cb37f1c6ec606433e34aa9bd0d6495f92d3fcc290cf298ed497b3967ab9beac5f60d18849f5bcc04df7bee34a39

data/context/best-practices.md

@@ -7,7 +7,7 @@ This guide gives an overview of best practices for using Async.
 `Async{}` has two uses: it creates an event loop if one doesn't exist, and it creates a task which runs asynchronously with respect to the parent scope. However, the top level `Async{}` block will be synchronous because it creates the event loop. In some programs, you do not care about executing asynchronously, but you still want your code to run in an event loop. `Sync{}` exists to do this efficiently.
 
 ```ruby
-require 'async'
+require "async"
 
 class Packages
 	def initialize(urls)
@@ -55,12 +55,24 @@ This expresses the intent to the caller that this method should only be invoked
 
 ## Use barriers to manage unbounded concurrency
 
-Barriers provide a way to manage an unbounded number of tasks.
+Barriers provide a way to manage an unbounded number of tasks. The top-level `Barrier` method creates a barrier with built-in load management using an `Async::Idler`.
 
 ```ruby
-Async do
-	barrier = Async::Barrier.new
-	
+Barrier do |barrier|
+	items.each do |item|
+		barrier.async do
+			process(item)
+		end
+	end
+end
+```
+
+The barrier will automatically wait for all tasks to complete and stop any outstanding tasks when the block exits. By default, it uses an `Async::Idler` to prevent system overload by scheduling tasks when the system load is below 80%.
+
+If you want to process tasks in order of completion, you can explicitly call `wait` with a block:
+
+```ruby
+Barrier do |barrier|
 	items.each do |item|
 		barrier.async do
 			process(item)
@@ -71,50 +83,61 @@ Async do
 	barrier.wait do |task|
 		result = task.wait
 		# Do something with result.
-
+		
 		# If you don't want to wait for any more tasks you can break:
 		break
 	end
-	
-	# Or just wait for all tasks to finish:
-	barrier.wait # May raise an exception if a task failed.
-ensure
-	# Stop all outstanding tasks in the barrier:
-	barrier&.stop
+end
+```
+
+To disable load management (not recommended for unbounded concurrency), you can pass `parent: nil`:
+
+```ruby
+Barrier(parent: nil) do |barrier|
+	# No load management - creates tasks as fast as possible
+	items.each do |item|
+		barrier.async do
+			process(item)
+		end
+	end
 end
 ```
 
 ## Use a semaphore to limit the number of concurrent tasks
 
-Semaphores allow you to limit the level of concurrency to a fixed number of tasks:
+Semaphores allow you to limit the level of concurrency to a fixed number of tasks. When using semaphores with barriers, the barrier should be the root of your task hierarchy, and the semaphore should be a child of the barrier:
 
 ```ruby
-Async do |task|
-	barrier = Async::Barrier.new
+Barrier(parent: nil) do |barrier|
 	semaphore = Async::Semaphore.new(4, parent: barrier)
 	
-	# Since the semaphore.async may block, we need to run the work scheduling in a child task:
-	task.async do
-		items.each do |item|
-			semaphore.async do
-				process(item)
-			end
+	items.each do |item|
+		semaphore.async do
+			process(item)
 		end
 	end
-	
-	# Wait for all the work to complete:
-	barrier.wait
-ensure
-	# Stop all outstanding tasks in the barrier:
-	barrier&.stop
 end
 ```
 
-In general, the barrier should be the root of your task hierarchy, and the semaphore should be a child of the barrier. This allows you to manage the lifetime of all tasks created by the semaphore, and ensures that all tasks are stopped when the barrier is stopped.
+In this example, we use `parent: nil` for the barrier to disable load management, since the semaphore already provides concurrency control. The semaphore limits execution to 4 concurrent tasks, and the barrier ensures all tasks are stopped when the block exits.
 
 ### Idler
 
-Idlers are like semaphores but with a limit defined by current processor utilization. In other words, an idler will do work up to a specific ratio of idle/busy time in the scheduler, and try to maintain that.
+Idlers are like semaphores but with a limit defined by current processor utilization. In other words, an idler will schedule work up to a specific ratio of idle/busy time in the scheduler.
+
+The top-level `Barrier` method uses an idler by default, making it safe for unbounded concurrency:
+
+```ruby
+Barrier do |barrier|  # Uses Async::Idler.new(0.8) by default
+	work.each do |work|
+		barrier.async do
+			work.call
+		end
+	end
+end
+```
+
+You can also use an idler directly without a barrier:
 
 ```ruby
 Async do
@@ -145,7 +168,7 @@ Async do |task|
 		while chunk = socket.gets
 			queue.push(chunk)
 		end
-	end
+		
 		# After this point, we won't be able to add items to the queue, and popping items will eventually result in nil once all items are dequeued:
 		queue.close
 	end

data/context/debugging.md

@@ -9,7 +9,7 @@ This guide explains how to debug issues with programs that use Async.
 The simplest way to debug an Async program is to use `puts` to print messages to the console. This is useful for understanding the flow of your program and the values of variables. However, it can be difficult to use `puts` to debug programs that use asynchronous code, as the output may be interleaved. To prevent this, wrap it in `Fiber.blocking{}`:
 
 ```ruby
-require 'async'
+require "async"
 
 Async do
 	3.times do |i|
@@ -42,8 +42,8 @@ If you don't use `Fiber.blocking{}`, the event loop will continue to run and you
 The `async-debug` gem provides a visual debugger for Async programs. It is a powerful tool that allows you to inspect the state of your program and see the hierarchy of your program:
 
 ```ruby
-require 'async'
-require 'async/debug'
+require "async"
+require "async/debug"
 
 Sync do
 	debugger = Async::Debug.serve

data/context/getting-started.md

@@ -65,7 +65,7 @@ You should consider the boundary around your program and the request handling. F
 Similar to a promise, {ruby Async::Task} produces results. In order to wait for these results, you must invoke {ruby Async::Task#wait}:
 
 ``` ruby
-require 'async'
+require "async"
 
 task = Async do
 	rand
@@ -99,7 +99,7 @@ end
 Unless you need fan-out, map-reduce style concurrency, you can actually use a slightly more efficient {ruby Kernel::Sync} execution model. This method will run your block in the current event loop if one exists, or create an event loop if not. You can use it for code which uses asynchronous primitives, but itself does not need to be asynchronous with respect to other tasks.
 
 ```ruby
-require 'async/http/internet'
+require "async/http/internet"
 
 def fetch(url)
 	Sync do
@@ -109,11 +109,11 @@ def fetch(url)
 end
 
 # At the level of your program, this method will create an event loop:
-fetch(...)
+fetch("https://example.com")
 
 Sync do
 	# The event loop already exists, and will be reused:
-	fetch(...)
+	fetch("https://example.com")
 end
 ```
 
@@ -154,13 +154,13 @@ The former allows you to inject the parent, which could be a barrier or semaphor
 The Fiber Scheduler interface is compatible with most pure Ruby code and well-behaved C code. For example, you can use {ruby Net::HTTP} for performing concurrent HTTP requests:
 
 ```ruby
-urls = [...]
+urls = ["http://example.com", "http://example.org", "http://example.net"]
 
 Async do
 	# Perform several concurrent requests:
 	responses = urls.map do |url|
 		Async do
-			Net::HTTP.get(url)
+			Net::HTTP.get(URI(url))
 		end
 	end.map(&:wait)
 end

data/context/scheduler.md

@@ -78,7 +78,7 @@ You can use this approach to embed the reactor in another event loop. For some i
 In order to integrate with native Ruby blocking operations, the {ruby Async::Scheduler} uses a {ruby Fiber::Scheduler} interface.
 
 ```ruby
-require 'async'
+require "async"
 
 scheduler = Async::Scheduler.new
 Fiber.set_scheduler(scheduler)

data/context/tasks.md

@@ -99,8 +99,8 @@ By constructing your program correctly, it's easy to implement concurrent map-re
 ```ruby
 Async do
 	# Map (create several concurrent tasks)
-	users_size = Async{User.size}
-	posts_size = Async{Post.size}
+	users_size = Async {User.size}
+	posts_size = Async {Post.size}
 	
 	# Reduce (wait for and merge the results)
 	average = posts_size.wait / users_size.wait
@@ -220,7 +220,7 @@ Async do
 			puts "Hello World #{i}"
 		end
 	end
-
+	
 	# Stop all the above tasks:
 	tasks.each(&:stop)
 end
@@ -414,8 +414,8 @@ and you could be handling 1000s of requests per second.
 The task doing the updating in the background is an implementation detail, so it is marked as `transient`.
 
 ```ruby
-require 'async'
-require 'thread/local' # thread-local gem.
+require "async"
+require "thread/local" # thread-local gem.
 
 class TimeStringCache
 	extend Thread::Local # defines `instance` class method that lazy-creates a separate instance per thread
@@ -450,4 +450,4 @@ Async do
 end
 ```
 
-Upon existing the top level async block, the {ruby @refresh} task will be set to `nil`. Bear in mind, you should not share these resources across threads; doing so would need some form of mutual exclusion.
+Upon exiting the top level async block, the {ruby @refresh} task will be set to `nil`. Bear in mind, you should not share these resources across threads; doing so would need some form of mutual exclusion.

data/context/thread-safety.md

@@ -106,11 +106,11 @@ Class variables (`@@variable`) and class attributes (`class_attribute`) represen
 ```ruby
 class GlobalConfig
 	@@settings = {} # Issue: Class variables are shared across inheritance
-
+	
 	def set(key, value)
 		@@settings[key] = value
 	end
-
+	
 	def get(key)
 		@@settings[key]
 	end
@@ -138,7 +138,7 @@ Lazy initialization is a common pattern in Ruby, but the `||=` operator is not a
 ```ruby
 class Loader
 	def self.data
-		@data ||= JSON.load_file('data.json')
+		@data ||= JSON.load_file("data.json")
 	end
 end
 ```
@@ -152,18 +152,18 @@ This could cause situations where `self.data != self.data` for example, or modif
 ```ruby
 class Loader
 	@mutex = Mutex.new
-
+	
 	def self.data
 		# Double-checked locking pattern:
 		return @data if @data
-
+		
 		@mutex.synchronize do
 			return @data if @data
-
+			
 			# Now we are sure that @data is nil, we can safely fetch it:
-			@data = JSON.load_file('data.json')
+			@data = JSON.load_file("data.json")
 		end
-
+		
 		return @data
 	end
 end
@@ -175,15 +175,15 @@ In addition, it should be noted that lazy initialization of a `Mutex` (and other
 class Loader
 	def self.data
 		@mutex ||= Mutex.new # Issue: Not thread-safe
-
+		
 		@mutex.synchronize do
 			# Double-checked locking pattern:
 			return @data if @data
-
+			
 			# Now we are sure that @data is nil, we can safely fetch it:
-			@data = JSON.load_file('data.json')
+			@data = JSON.load_file("data.json")
 		end
-
+		
 		return @data
 	end
 end
@@ -214,7 +214,7 @@ Like lazy initialization, memoization using `Hash` caches can lead to race condi
 ```ruby
 class ExpensiveComputation
 	@cache = {}
-
+	
 	def self.compute(key)
 		@cache[key] ||= expensive_operation(key) # Issue: Not thread-safe
 	end
@@ -231,7 +231,7 @@ Note that this mutex creates contention on all calls to `compute`, which can be
 class ExpensiveComputation
 	@cache = {}
 	@mutex = Mutex.new
-
+	
 	def self.compute(key)
 		@mutex.synchronize do
 			@cache[key] ||= expensive_operation(key)
@@ -245,7 +245,7 @@ end
 ```ruby
 class ExpensiveComputation
 	@cache = Concurrent::Map.new
-
+	
 	def self.compute(key)
 		@cache.compute_if_absent(key) do
 			expensive_operation(key)
@@ -320,7 +320,7 @@ end
 Using a connection pool can help manage shared connections safely:
 
 ```ruby
-require 'connection_pool'
+require "connection_pool"
 pool = ConnectionPool.new(size: 5, timeout: 5) do
 	Database.connect
 end
@@ -347,11 +347,11 @@ class SharedList
 	def initialize
 		@list = []
 	end
-
+	
 	def add(item)
 		@list << item
 	end
-
+	
 	def each(&block)
 		# Issue: Modifications during enumeration can lead to inconsistent state
 		@list.each(&block)
@@ -373,13 +373,13 @@ class SharedList
 		@list = []
 		@mutex = Mutex.new
 	end
-
+	
 	def add(item)
 		@mutex.synchronize do
 			@list << item
 		end
 	end
-
+	
 	def each(&block)
 		@mutex.synchronize do
 			@list.each(&block)
@@ -439,14 +439,14 @@ class System
 		@condition = ConditionVariable.new
 		@usage = 0
 	end
-
+	
 	def release
 		@mutex.synchronize do
 			@usage -= 1
 			@condition.signal if @usage == 0
 		end
 	end
-
+	
 	def wait_until_free
 		@mutex.synchronize do
 			while @usage > 0
@@ -462,11 +462,11 @@ end
 External resources can also lead to "time of check to time of use" issues, where the state of the resource changes between checking its status and using it.
 
 ```ruby
-if File.exist?('cache.json')
-	@data = File.read('cache.json')
+if File.exist?("cache.json")
+	@data = File.read("cache.json")
 else
 	@data = fetch_data_from_api
-	File.write('cache.json', @data)
+	File.write("cache.json", @data)
 end
 ```
 
@@ -480,9 +480,9 @@ Using content-addressable storage and atomic file operations can help avoid race
 
 ```ruby
 begin
-	File.read('cache.json')
+	File.read("cache.json")
 rescue Errno::ENOENT
-	File.open('cache.json', 'w') do |file|
+	File.open("cache.json", "w") do |file|
 		file.flock(File::LOCK_EX)
 		file.write(fetch_data_from_api)
 	end
@@ -546,7 +546,7 @@ Use `Fiber[key]` when you need per-request state that **inherits across concurre
 
 ```ruby
 Fiber[:user_id] = request.session[:user_id]
-Fiber[:trace_id] = request.headers['X-Trace-ID']
+Fiber[:trace_id] = request.headers["X-Trace-ID"]
 
 jobs.each do |job|
 	Thread.new do
@@ -617,13 +617,13 @@ class Counter
 		@count = count
 		@mutex = Mutex.new
 	end
-
+	
 	def increment
 		@mutex.synchronize do
 			@count += 1
 		end
 	end
-
+	
 	def times
 		@mutex.synchronize do
 			@count.times do |i|
@@ -650,10 +650,10 @@ As an alternative to the above, reducing the scope of the lock can help avoid de
 ```ruby
 class Counter
 	# ...
-
+	
 	def times
 		count = @mutex.synchronize{@count}
-
+		
 		# Avoid holding the lock while yielding to user code:
 		count.times do |i|
 			yield i

data/lib/async/deadline.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
+# Copyright, 2025, by Shopify Inc.
 # Copyright, 2025, by Samuel Williams.
 
 require_relative "clock"

data/lib/async/fork_handler.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Shopify Inc.
+# Copyright, 2025, by Samuel Williams.
+
+module Async
+	# Private module that hooks into Process._fork to handle fork events.
+	#
+	# If `Scheduler#process_fork` hook is adopted in Ruby 4, this code can be removed after Ruby < 4 is no longer supported.
+	module ForkHandler
+		def _fork(&block)
+			result = super
+			
+			if result.zero?
+				# Child process:
+				if Fiber.scheduler.respond_to?(:process_fork)
+					Fiber.scheduler.process_fork
+				end
+			end
+			
+			return result
+		end
+	end
+	
+	private_constant :ForkHandler
+	
+	# Hook into Process._fork to handle fork events automatically:
+	unless (Fiber.const_get(:SCHEDULER_PROCESS_FORK) rescue false)
+		::Process.singleton_class.prepend(ForkHandler)
+	end
+end

data/lib/async/idler.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2024, by Samuel Williams.
+# Copyright, 2024-2025, by Samuel Williams.
 
 module Async
 	# A load balancing mechanism that can be used process work when the system is idle.

data/lib/async/node.rb

@@ -214,7 +214,8 @@ module Async
 		end
 		
 		protected def remove_child(child)
-			@children.remove(child)
+			# In the case of a fork, the children list may be nil:
+			@children&.remove(child)
 			child.set_parent(nil)
 		end
 		

data/lib/async/promise.rb

@@ -30,39 +30,39 @@ module Async
 		
 		# @returns [Boolean] Whether the promise has been resolved or rejected.
 		def resolved?
-			@mutex.synchronize {!!@resolved}
+			@mutex.synchronize{!!@resolved}
 		end
 		
 		# @returns [Symbol | Nil] The internal resolved state (:completed, :failed, :cancelled, or nil if pending).
 		# @private For internal use by Task.
 		def resolved
-			@mutex.synchronize {@resolved}
+			@mutex.synchronize{@resolved}
 		end
 		
 		# @returns [Boolean] Whether the promise has been cancelled.
 		def cancelled?
-			@mutex.synchronize {@resolved == :cancelled}
+			@mutex.synchronize{@resolved == :cancelled}
 		end
 		
 		# @returns [Boolean] Whether the promise failed with an exception.
 		def failed?
-			@mutex.synchronize {@resolved == :failed}
+			@mutex.synchronize{@resolved == :failed}
 		end
 		
 		# @returns [Boolean] Whether the promise has completed successfully.
 		def completed?
-			@mutex.synchronize {@resolved == :completed}
+			@mutex.synchronize{@resolved == :completed}
 		end
 		
 		# @returns [Boolean] Whether any fibers are currently waiting for this promise.
 		def waiting?
-			@mutex.synchronize {@waiting > 0}
+			@mutex.synchronize{@waiting > 0}
 		end
 		
 		# Artificially mark that someone is waiting (useful for suppressing warnings).
 		# @private Internal use only.
 		def suppress_warnings!
-			@mutex.synchronize {@waiting += 1}
+			@mutex.synchronize{@waiting += 1}
 		end
 		
 		# Non-blocking access to the current value. Returns nil if not yet resolved.
@@ -71,7 +71,7 @@ module Async
 		#
 		# @returns [Object | Nil] The stored value, or nil if pending.
 		def value
-			@mutex.synchronize {@resolved ? @value : nil}
+			@mutex.synchronize{@resolved ? @value : nil}
 		end
 		
 		# Wait for the promise to be resolved and return the value.

data/lib/async/queue.rb

@@ -72,7 +72,7 @@ module Async
 		
 		# Add multiple items to the queue.
 		def enqueue(*items)
-			items.each {|item| @delegate.push(item)}
+			items.each{|item| @delegate.push(item)}
 		rescue ClosedQueueError
 			raise ClosedError, "Cannot enqueue items to a closed queue!"
 		end

data/lib/async/scheduler.rb

@@ -9,6 +9,7 @@
 require_relative "clock"
 require_relative "task"
 require_relative "timeout"
+require_relative "fork_handler"
 
 require "io/event"
 
@@ -146,24 +147,26 @@ module Async
 		# Terminate all child tasks and close the scheduler.
 		# @public Since *Async v1*.
 		def close
-			self.run_loop do
-				until self.terminate
-					self.run_once!
+			unless @children.nil?
+				self.run_loop do
+					until self.terminate
+						self.run_once!
+					end
 				end
 			end
 			
 			Kernel.raise "Closing scheduler with blocked operations!" if @blocked > 0
 		ensure
 			# We want `@selector = nil` to be a visible side effect from this point forward, specifically in `#interrupt` and `#unblock`. If the selector is closed, then we don't want to push any fibers to it.
-			selector = @selector
-			@selector = nil
-			
-			selector&.close
-			
-			worker_pool = @worker_pool
-			@worker_pool = nil
+			if selector = @selector
+				@selector = nil
+				selector.close
+			end
 			
-			worker_pool&.close
+			if worker_pool = @worker_pool
+				@worker_pool = nil
+				worker_pool.close
+			end
 			
 			consume
 		end
@@ -642,5 +645,24 @@ module Async
 				yield duration
 			end
 		end
+		
+		# Handle fork in the child process. This method is called automatically when `Process.fork` is invoked.
+		#
+		# The child process starts with a clean slate - no scheduler is set. Users can create a new scheduler if needed.
+		#
+		# @public Since *Async v2.35*.
+		def process_fork
+			if profiler = @profiler
+				@profiler = nil
+				profiler.stop
+			end
+			
+			@children = nil
+			@selector = nil
+			@timers = nil
+			
+			# Close the scheduler:
+			Fiber.set_scheduler(nil)
+		end
 	end
 end

data/lib/async/task.md

@@ -21,7 +21,7 @@ Initialized --> Stopped : Stop
 ## Example
 
 ```ruby
-require 'async'
+require "async"
 
 # Create an asynchronous task that sleeps for 1 second:
 Async do |task|

data/lib/async/version.rb

@@ -4,5 +4,5 @@
 # Copyright, 2017-2025, by Samuel Williams.
 
 module Async
-	VERSION = "2.34.0"
+	VERSION = "2.35.0"
 end

data/lib/async.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2017-2024, by Samuel Williams.
+# Copyright, 2017-2025, by Samuel Williams.
 # Copyright, 2020, by Salim Semaoune.
 
 require_relative "async/version"

data/lib/kernel/sync.rb

@@ -20,7 +20,7 @@ module Kernel
 	def Sync(annotation: nil, &block)
 		if task = ::Async::Task.current?
 			if annotation
-				task.annotate(annotation) {yield task}
+				task.annotate(annotation){yield task}
 			else
 				yield task
 			end

data/lib/traces/provider/async/barrier.rb

@@ -12,6 +12,6 @@ Traces::Provider(Async::Barrier) do
 			"size" => self.size
 		}
 		
-		Traces.trace("async.barrier.wait", attributes: attributes) {super}
+		Traces.trace("async.barrier.wait", attributes: attributes){super}
 	end
 end

data/license.md

@@ -34,6 +34,7 @@ Copyright, 2025, by Alan Wu.
 Copyright, 2025, by Shopify Inc.  
 Copyright, 2025, by Josh Teeter.  
 Copyright, 2025, by Jatin Goyal.  
+Copyright, 2025, by Yuhi Sato.  
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/readme.md

@@ -35,6 +35,10 @@ Please see the [project documentation](https://socketry.github.io/async/) for mo
 
 Please see the [project releases](https://socketry.github.io/async/releases/index) for all releases.
 
+### v2.35.0
+
+  - `Process.fork` is now properly handled by the Async fiber scheduler, ensuring that the scheduler state is correctly reset in the child process after a fork. This prevents issues where the child process inherits the scheduler state from the parent, which could lead to unexpected behavior.
+
 ### v2.34.0
 
   - [`Kernel::Barrier` Convenience Interface](https://socketry.github.io/async/releases/index#kernel::barrier-convenience-interface)
@@ -80,18 +84,13 @@ This release introduces thread-safety as a core concept of Async. Many core clas
 
   - Use `Traces.current_context` and `Traces.with_context` for better integration with OpenTelemetry.
 
-### v2.27.4
-
-  - Suppress excessive warning in `Async::Scheduler#async`.
-
 ## See Also
 
   - [async-http](https://github.com/socketry/async-http) — Asynchronous HTTP client/server.
+  - [falcon](https://github.com/socketry/falcon) — A rack compatible server built on top of `async-http`.
   - [async-websocket](https://github.com/socketry/async-websocket) — Asynchronous client and server websockets.
   - [async-dns](https://github.com/socketry/async-dns) — Asynchronous DNS resolver and server.
-  - [falcon](https://github.com/socketry/falcon) — A rack compatible server built on top of `async-http`.
-  - [rubydns](https://github.com/ioquatix/rubydns) — An easy to use Ruby DNS server.
-  - [slack-ruby-bot](https://github.com/slack-ruby/slack-ruby-bot) — A client for making slack bots.
+  - [toolbox](https://github.com/socketry/toolbox) — GDB & LLDB extensions for debugging Ruby applications with Fibers.
 
 ## Contributing
 

data/releases.md

@@ -1,5 +1,9 @@
 # Releases
 
+## v2.35.0
+
+  - `Process.fork` is now properly handled by the Async fiber scheduler, ensuring that the scheduler state is correctly reset in the child process after a fork. This prevents issues where the child process inherits the scheduler state from the parent, which could lead to unexpected behavior.
+
 ## v2.34.0
 
 ### `Kernel::Barrier` Convenience Interface
@@ -7,7 +11,7 @@
 Starting multiple concurrent tasks and waiting for them to finish is a common pattern. This change introduces a small ergonomic helper, `Barrier`, defined in `Kernel`, that encapsulates this behavior: it creates an `Async::Barrier`, yields it to a block, waits for completion (using `Sync` to run a reactor if needed), and ensures remaining tasks are stopped on exit.
 
 ``` ruby
-require 'async'
+require "async"
 
 Barrier do |barrier|
 	3.times do |i|
@@ -66,15 +70,15 @@ This release introduces the new `Async::Promise` class and refactors `Async::Tas
 <!-- end list -->
 
 ``` ruby
-require 'async/promise'
+require "async/promise"
 
 # Basic promise usage - works independently of Async framework
 promise = Async::Promise.new
 
 # In another thread or fiber, resolve the promise
 Thread.new do
-  sleep(1)  # Simulate some work
-  promise.resolve("Hello, World!")
+	sleep(1)  # Simulate some work
+	promise.resolve("Hello, World!")
 end
 
 # Wait for the result
@@ -93,34 +97,34 @@ Promises bridge Thread and Fiber concurrency models - a promise resolved in one
 The new `Async::PriorityQueue` provides a thread-safe, fiber-aware queue where consumers can specify priority levels. Higher priority consumers are served first when items become available, with FIFO ordering maintained for equal priorities. This is useful for implementing priority-based task processing systems where critical operations need to be handled before lower priority work.
 
 ``` ruby
-require 'async'
-require 'async/priority_queue'
+require "async"
+require "async/priority_queue"
 
 Async do
-  queue = Async::PriorityQueue.new
-  
-  # Start consumers with different priorities
-  low_priority = async do
-    puts "Low priority consumer got: #{queue.dequeue(priority: 1)}"
-  end
-  
-  medium_priority = async do
-    puts "Medium priority consumer got: #{queue.dequeue(priority: 5)}"
-  end
-  
-  high_priority = async do
-    puts "High priority consumer got: #{queue.dequeue(priority: 10)}"
-  end
-  
-  # Add items to the queue
-  queue.push("first item")
-  queue.push("second item")
-  queue.push("third item")
-  
-  # Output:
-  # High priority consumer got: first item
-  # Medium priority consumer got: second item  
-  # Low priority consumer got: third item
+	queue = Async::PriorityQueue.new
+	
+		# Start consumers with different priorities
+	low_priority = async do
+		puts "Low priority consumer got: #{queue.dequeue(priority: 1)}"
+	end
+	
+	medium_priority = async do
+		puts "Medium priority consumer got: #{queue.dequeue(priority: 5)}"
+	end
+	
+	high_priority = async do
+		puts "High priority consumer got: #{queue.dequeue(priority: 10)}"
+	end
+	
+		# Add items to the queue
+	queue.push("first item")
+	queue.push("second item")
+	queue.push("third item")
+	
+		# Output:
+		# High priority consumer got: first item
+		# Medium priority consumer got: second item  
+		# Low priority consumer got: third item
 end
 ```
 
@@ -370,10 +374,10 @@ This gives better visibility into what the scheduler is doing, and should help d
 The `async` gem depends on `console` gem, because my goal was to have good logging by default without thinking about it too much. However, some users prefer to avoid using the `console` gem for logging, so I've added an experimental set of shims which should allow you to bypass the `console` gem entirely.
 
 ``` ruby
-require 'async/console'
-require 'async'
+require "async/console"
+require "async"
 
-Async{raise "Boom"}
+Async {raise "Boom"}
 ```
 
 Will now use `Kernel#warn` to print the task failure warning:
@@ -407,7 +411,7 @@ reactor = Async::Reactor.new # internally calls Fiber.set_scheduler
 
 # This should run in the above reactor, rather than creating a new one.
 Async do
-  puts "Hello World"
+	puts "Hello World"
 end
 ```
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async
 version: !ruby/object:Gem::Version
-  version: 2.34.0
+  version: 2.35.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -38,6 +38,7 @@ authors:
 - Sokolov Yura
 - Stefan Wrobel
 - Trevor Turk
+- Yuhi Sato
 bindir: bin
 cert_chain:
 - |
@@ -160,6 +161,7 @@ files:
 - lib/async/condition.rb
 - lib/async/console.rb
 - lib/async/deadline.rb
+- lib/async/fork_handler.rb
 - lib/async/idler.rb
 - lib/async/limited_queue.rb
 - lib/async/list.rb