Remove thread local registry.

Author: samuel-williams-shopify

lib/async/utilization.rb

@@ -15,42 +15,9 @@ module Async
 	#
 	# This module provides a convenient interface for tracking utilization metrics
 	# that can be synchronized to shared memory for inter-process communication.
-	# Each thread gets its own instance of the underlying {Registry}, providing
-	# thread-local behavior.
+	# Registries should be explicitly created and passed to components that need them.
 	#
 	# See the {file:guides/getting-started/readme.md Getting Started} guide for usage examples.
 	module Utilization
-		# Set the observer for utilization metrics.
-		#
-		# When an observer is set, it is notified of all current metric values
-		# so it can sync its state. The observer must implement `set(field, value)`.
-		#
-		# Delegates to the thread-local {Registry} instance.
-		#
-		# @parameter observer [#set] The observer to set.
-		def self.observer=(observer)
-			Registry.instance.observer = observer
-		end
-		
-		# Get a cached metric reference for a field.
-		#
-		# Returns a {Metric} instance that caches all details needed for fast writes
-		# to shared memory, avoiding hash lookups on the fast path.
-		#
-		# This is the recommended way to access metrics for optimal performance.
-		#
-		# Delegates to the thread-local {Registry} instance.
-		#
-		# @parameter field [Symbol] The field name to get a metric for.
-		# @returns [Metric] A metric instance for the given field.
-		# @example Get a metric and increment it:
-		# 	current_requests = Async::Utilization.metric(:current_requests)
-		# 	current_requests.increment
-		# 	current_requests.increment do
-		# 		# Handle request - auto-decrements when block completes
-		# 	end
-		def self.metric(field)
-			Registry.instance.metric(field)
-		end
 	end
 end

lib/async/utilization/registry.rb

@@ -3,17 +3,16 @@
 # Released under the MIT License.
 # Copyright, 2026, by Samuel Williams.
 
-require "thread/local"
-
 module Async
 	module Utilization
 		# Registry for emitting utilization metrics.
 		#
 		# The registry tracks values directly and notifies a registered observer
 		# when values change. The observer (like Observer) can write to its backend.
 		#
-		# Each thread gets its own instance of the registry, providing
-		# thread-local behavior through the thread-local gem.
+		# Registries should be explicitly created and passed to components that need them.
+		# In service contexts, registries are typically created via the evaluator and
+		# shared across components within the same service instance.
 		#
 		# When an observer is added, it is immediately notified of all current values
 		# so it can sync its state. When values change, the observer is notified.
@@ -36,7 +35,6 @@ module Utilization
 		# 	observer = Async::Utilization::Observer.open(schema, "/path/to/shm", 4096, 0)
 		# 	registry.observer = observer
 		class Registry
-			extend Thread::Local
 
 			# Initialize a new registry.
 			def initialize

test/async/utilization/metric.rb

@@ -29,28 +29,24 @@
 		Async::Utilization::Observer.open(schema, shm_path, segment_size, offset)
 	end
 
+	let(:registry) {Async::Utilization::Registry.new}
+	
 	before do
 		File.open(shm_path, "w+b") do |file|
 			file.truncate(file_size)
 		end
-		
-		# Reset the registry to ensure clean state between tests
-		registry = Async::Utilization::Registry.instance
-		registry.instance_variable_set(:@values, Hash.new(0))
-		registry.instance_variable_set(:@metrics, {})
-		registry.instance_variable_set(:@observer, nil)
 	end
 
 	it "can create a metric from a field name" do
-		metric = Async::Utilization.metric(:total_requests)
+		metric = registry.metric(:total_requests)
 
 		expect(metric).to be_a(Async::Utilization::Metric)
 		expect(metric.name).to be == :total_requests
 	end
 
 	it "can increment a metric" do
-		Async::Utilization.observer = observer
-		metric = Async::Utilization.metric(:total_requests)
+		registry.observer = observer
+		metric = registry.metric(:total_requests)
 
 		value = metric.increment
 		expect(value).to be == 1
@@ -62,8 +58,8 @@
 	end
 
 	it "can decrement a metric" do
-		Async::Utilization.observer = observer
-		metric = Async::Utilization.metric(:total_requests)
+		registry.observer = observer
+		metric = registry.metric(:total_requests)
 
 		metric.increment
 		metric.increment
@@ -74,8 +70,8 @@
 	end
 
 	it "can set a metric value" do
-		Async::Utilization.observer = observer
-		metric = Async::Utilization.metric(:total_requests)
+		registry.observer = observer
+		metric = registry.metric(:total_requests)
 
 		metric.set(42)
 		expect(metric.value).to be == 42
@@ -85,8 +81,8 @@
 	end
 
 	it "can increment with auto-decrement block" do
-		Async::Utilization.observer = observer
-		metric = Async::Utilization.metric(:active_requests)
+		registry.observer = observer
+		metric = registry.metric(:active_requests)
 
 		metric.increment do
 			expect(metric.value).to be == 1
@@ -96,8 +92,8 @@
 	end
 
 	it "decrements even if block raises an error" do
-		Async::Utilization.observer = observer
-		metric = Async::Utilization.metric(:active_requests)
+		registry.observer = observer
+		metric = registry.metric(:active_requests)
 
 		begin
 			metric.increment do
@@ -111,8 +107,8 @@
 	end
 
 	it "writes directly to shared memory when observer is set" do
-		Async::Utilization.observer = observer
-		metric = Async::Utilization.metric(:total_requests)
+		registry.observer = observer
+		metric = registry.metric(:total_requests)
 
 		metric.set(42)
 
@@ -122,8 +118,8 @@
 	end
 
 	it "invalidates cache when observer changes" do
-		Async::Utilization.observer = observer
-		metric = Async::Utilization.metric(:total_requests)
+		registry.observer = observer
+		metric = registry.metric(:total_requests)
 
 		# Set a value - cache should be built
 		metric.set(10)
@@ -139,7 +135,7 @@
 		new_observer = Async::Utilization::Observer.open(new_schema, new_shm_path, segment_size, 0)
 
 		# Change observer - cache should be invalidated
-		Async::Utilization.observer = new_observer
+		registry.observer = new_observer
 
 		# Set a new value - cache should be rebuilt
 		metric.set(20)
@@ -151,7 +147,7 @@
 	end
 
 	it "works without an observer" do
-		metric = Async::Utilization.metric(:total_requests)
+		metric = registry.metric(:total_requests)
 
 		# Should work fine without observer (uses fallback path)
 		metric.increment
@@ -161,21 +157,21 @@
 		expect(metric.value).to be == 5
 
 		# Set observer and verify it works with fast path
-		Async::Utilization.observer = observer
+		registry.observer = observer
 		metric.set(10)
 		expect(metric.value).to be == 10
 	end
 
 	it "returns the same metric instance for the same field" do
-		metric1 = Async::Utilization.metric(:total_requests)
-		metric2 = Async::Utilization.metric(:total_requests)
+		metric1 = registry.metric(:total_requests)
+		metric2 = registry.metric(:total_requests)
 
 		expect(metric1).to be == metric2
 	end
 
 	it "falls back to observer.set when write_direct fails" do
-		Async::Utilization.observer = observer
-		metric = Async::Utilization.metric(:total_requests)
+		registry.observer = observer
+		metric = registry.metric(:total_requests)
 
 		# Force cache to be invalid by invalidating it
 		metric.invalidate
@@ -190,8 +186,8 @@
 	end
 
 	it "handles write errors gracefully" do
-		Async::Utilization.observer = observer
-		metric = Async::Utilization.metric(:total_requests)
+		registry.observer = observer
+		metric = registry.metric(:total_requests)
 
 		# Set a value first to build the cache
 		metric.set(10)