graphiti 1.7.9 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb170ab1193913adfcc8a371c4fc6bd8d19ac18e0179dc5c8b08f5e0afb2bfbd
-  data.tar.gz: 11b2b551351dd11bacc20ee275cfc4588c48659f60511d48f7c688ba4c0fc7e3
+  metadata.gz: 5530b650ab32f95fd4ed881afc07d68b5a252fa416959f19e8cced55de5266d2
+  data.tar.gz: 3054b7eb3cf13f3e6a744690fbc95ef38b010e6f8e7f4f6b9365696e9395c07a
 SHA512:
-  metadata.gz: 83b1608a927b6f034ec460eefa14139d44be383941a00f5834dd7895c2ddc1b44a0da4d3d33f1779d12c00ef7b76451c9616a014e1fcd97f00916b19fa3296bf
-  data.tar.gz: 8dbc78fe342175e22d9f8668b882c7ac5184ac738f6d32ea63209dcd9893eb7ad713bf4875ed47ac703f79d9f66220ed9b47b0ba32fbf4d80b78d37a5e683edf
+  metadata.gz: 25dea9d82d42029ddb9f7cf5f0770005bf69c265531bcac22e89f843381abc29aa40b533ff00920c84a0ecdde2d889b423b16c1585f349e2d1c81abfdf877bdf
+  data.tar.gz: 348f6928dad9f049376b7971924014cf24d458c36159978bdd9996cd7b33da151b49426765361586b46c5a3a410820a57f14854854c349b42e8c79b8a07c4048

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 graphiti changelog
 
+# [1.8.0](https://github.com/graphiti-api/graphiti/compare/v1.7.9...v1.8.0) (2025-03-17)
+
+
+### Features
+
+* add thread pool with promises to limit concurrent sideloading ([#472](https://github.com/graphiti-api/graphiti/issues/472)) ([2998852](https://github.com/graphiti-api/graphiti/commit/2998852cea3e5f366e3748d808e26e83e484e989))
+
 ## [1.7.9](https://github.com/graphiti-api/graphiti/compare/v1.7.8...v1.7.9) (2025-03-16)
 
 

data/graphiti.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "jsonapi-renderer", "~> 0.2", ">= 0.2.2"
   spec.add_dependency "dry-types", ">= 0.15.0", "< 2.0"
   spec.add_dependency "graphiti_errors", "~> 1.1.0"
-  spec.add_dependency "concurrent-ruby", "~> 1.0"
+  spec.add_dependency "concurrent-ruby", ">= 1.2", "< 2.0"
   spec.add_dependency "activesupport", ">= 5.2"
 
   spec.add_development_dependency "faraday", "~> 0.15"

data/lib/graphiti/configuration.rb

@@ -8,6 +8,20 @@ module Graphiti
     #   Defaults to false OR if classes are cached (Rails-only)
     attr_accessor :concurrency
 
+    # This number must be considered in accordance with the database
+    # connection pool size configured in `database.yml`. The connection
+    # pool should be large enough to accommodate both the foreground
+    # threads (ie. web server or job worker threads) and background
+    # threads. For each process, Graphiti will create one global
+    # executor that uses this many threads to sideload resources
+    # asynchronously. Thus, the pool size should be at least
+    # `thread_count + concurrency_max_threads + 1`. For example, if your
+    # web server has a maximum of 3 threads, and
+    # `concurrency_max_threads` is set to 4, then your pool size should
+    # be at least 8.
+    # @return [Integer] Maximum number of threads to use when fetching sideloads concurrently
+    attr_accessor :concurrency_max_threads
+
     attr_accessor :respond_to
     attr_accessor :context_for_endpoint
     attr_accessor :links_on_demand
@@ -28,6 +42,7 @@ module Graphiti
     def initialize
       @raise_on_missing_sideload = true
       @concurrency = false
+      @concurrency_max_threads = 4
       @respond_to = [:json, :jsonapi, :xml]
       @links_on_demand = false
       @pagination_links_on_demand = false

data/lib/graphiti/resource_proxy.rb

@@ -77,9 +77,8 @@ module Graphiti
     def data
       @data ||= begin
         records = @scope.resolve
-        if records.empty? && raise_on_missing?
-          raise Graphiti::Errors::RecordNotFound
-        end
+        raise Graphiti::Errors::RecordNotFound if records.empty? && raise_on_missing?
+
         records = records[0] if single?
         records
       end
@@ -87,6 +86,15 @@ module Graphiti
     alias_method :to_a, :data
     alias_method :resolve_data, :data
 
+    def future_resolve_data
+      @scope.future_resolve.then do |records|
+        raise Graphiti::Errors::RecordNotFound if records.empty? && raise_on_missing?
+
+        records = records[0] if single?
+        @data = records
+      end
+    end
+
     def meta
       @meta ||= data.respond_to?(:meta) ? data.meta : {}
     end

data/lib/graphiti/scope.rb

@@ -2,6 +2,35 @@ module Graphiti
   class Scope
     attr_accessor :object, :unpaginated_object
     attr_reader :pagination
+
+    GLOBAL_THREAD_POOL_EXECUTOR_BROADCAST_STATS = %i[
+      length max_length queue_length max_queue completed_task_count largest_length scheduled_task_count synchronous
+    ]
+    GLOBAL_THREAD_POOL_EXECUTOR = Concurrent::Promises.delay do
+      if Graphiti.config.concurrency
+        concurrency = Graphiti.config.concurrency_max_threads || 4
+        Concurrent::ThreadPoolExecutor.new(
+          min_threads: 0,
+          max_threads: concurrency,
+          max_queue: concurrency * 4,
+          fallback_policy: :caller_runs
+        )
+      else
+        Concurrent::ThreadPoolExecutor.new(max_threads: 0, synchronous: true, fallback_policy: :caller_runs)
+      end
+    end
+    private_constant :GLOBAL_THREAD_POOL_EXECUTOR, :GLOBAL_THREAD_POOL_EXECUTOR_BROADCAST_STATS
+
+    def self.global_thread_pool_executor
+      GLOBAL_THREAD_POOL_EXECUTOR.value!
+    end
+
+    def self.global_thread_pool_stats
+      GLOBAL_THREAD_POOL_EXECUTOR_BROADCAST_STATS.each_with_object({}) do |key, memo|
+        memo[key] = global_thread_pool_executor.send(key)
+      end
+    end
+
     def initialize(object, resource, query, opts = {})
       @object = object
       @resource = resource
@@ -14,57 +43,33 @@ module Graphiti
     end
 
     def resolve
-      if @query.zero_results?
-        []
-      else
-        resolved = broadcast_data { |payload|
-          @object = @resource.before_resolve(@object, @query)
-          payload[:results] = @resource.resolve(@object)
-          payload[:results]
-        }
-        resolved.compact!
-        assign_serializer(resolved)
-        yield resolved if block_given?
-        @opts[:after_resolve]&.call(resolved)
-        resolve_sideloads(resolved) unless @query.sideloads.empty?
-        resolved
-      end
+      future_resolve.value!
     end
 
     def resolve_sideloads(results)
-      return if results == []
+      future_resolve_sideloads(results).value!
+    end
 
-      concurrent = Graphiti.config.concurrency
-      promises = []
+    def future_resolve
+      return Concurrent::Promises.fulfilled_future([], self.class.global_thread_pool_executor) if @query.zero_results?
 
-      @query.sideloads.each_pair do |name, q|
-        sideload = @resource.class.sideload(name)
-        next if sideload.nil? || sideload.shared_remote?
-        parent_resource = @resource
-        graphiti_context = Graphiti.context
-        resolve_sideload = -> {
-          Graphiti.config.before_sideload&.call(graphiti_context)
-          Graphiti.context = graphiti_context
-          sideload.resolve(results, q, parent_resource)
-          @resource.adapter.close if concurrent
-        }
-        if concurrent
-          promises << Concurrent::Promise.execute(&resolve_sideload)
-        else
-          resolve_sideload.call
-        end
+      resolved = broadcast_data { |payload|
+        @object = @resource.before_resolve(@object, @query)
+        payload[:results] = @resource.resolve(@object)
+        payload[:results]
+      }
+      resolved.compact!
+      assign_serializer(resolved)
+      yield resolved if block_given?
+      @opts[:after_resolve]&.call(resolved)
+      sideloaded = @query.parents.any?
+      close_adapter = Graphiti.config.concurrency && sideloaded
+      if close_adapter
+        @resource.adapter.close
       end
 
-      if concurrent
-        # Wait for all promises to finish
-        sleep 0.01 until promises.all? { |p| p.fulfilled? || p.rejected? }
-        # Re-raise the error with correct stacktrace
-        # OPTION** to avoid failing here?? if so need serializable patch
-        # to avoid loading data when association not loaded
-        if (rejected = promises.find(&:rejected?))
-          raise rejected.reason
-        end
-      end
+      future_resolve_sideloads(resolved)
+        .then_on(self.class.global_thread_pool_executor, resolved) { resolved }
     end
 
     def parent_resource
@@ -108,6 +113,74 @@ module Graphiti
 
     private
 
+    def future_resolve_sideloads(results)
+      return Concurrent::Promises.fulfilled_future(nil, self.class.global_thread_pool_executor) if results == []
+
+      sideload_promises = @query.sideloads.filter_map do |name, q|
+        sideload = @resource.class.sideload(name)
+        next if sideload.nil? || sideload.shared_remote?
+
+        p = future_with_context(results, q, @resource) do |parent_results, sideload_query, parent_resource|
+          Graphiti.config.before_sideload&.call(Graphiti.context)
+          sideload.future_resolve(parent_results, sideload_query, parent_resource)
+        end
+        p.flat
+      end
+
+      Concurrent::Promises.zip_futures_on(self.class.global_thread_pool_executor, *sideload_promises)
+        .rescue_on(self.class.global_thread_pool_executor) do |*reasons|
+          first_error = reasons.find { |r| r.is_a?(Exception) }
+          raise first_error
+        end
+    end
+
+    def future_with_context(*args)
+      thread_storage = Thread.current.keys.each_with_object({}) do |key, memo|
+        memo[key] = Thread.current[key]
+      end
+      fiber_storage =
+        if Fiber.current.respond_to?(:storage)
+          Fiber.current&.storage&.keys&.each_with_object({}) do |key, memo|
+            memo[key] = Fiber[key]
+          end
+        end
+
+      Concurrent::Promises.future_on(
+        self.class.global_thread_pool_executor, Thread.current.object_id, thread_storage, fiber_storage, *args
+      ) do |thread_id, thread_storage, fiber_storage, *args|
+        wrap_in_rails_executor do
+          execution_context_changed = thread_id != Thread.current.object_id
+          if execution_context_changed
+            thread_storage&.keys&.each_with_object(Thread.current) do |key, thread_current|
+              thread_current[key] = thread_storage[key]
+            end
+            fiber_storage&.keys&.each_with_object(Fiber) do |key, fiber_current|
+              fiber_current[key] = fiber_storage[key]
+            end
+          end
+
+          result = Graphiti.broadcast(:global_thread_pool_task_run, self.class.global_thread_pool_stats) do
+            yield(*args)
+          end
+
+          if execution_context_changed
+            thread_storage&.keys&.each { |key| Thread.current[key] = nil }
+            fiber_storage&.keys&.each { |key| Fiber[key] = nil }
+          end
+
+          result
+        end
+      end
+    end
+
+    def wrap_in_rails_executor(&block)
+      if defined?(::Rails.application.executor)
+        ::Rails.application.executor.wrap(&block)
+      else
+        yield
+      end
+    end
+
     def sideload_resource_proxies
       @sideload_resource_proxies ||= begin
         @object = @resource.before_resolve(@object, @query)

data/lib/graphiti/sideload/polymorphic_belongs_to.rb

@@ -108,18 +108,23 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
   end
 
   def resolve(parents, query, graph_parent)
-    parents.group_by(&grouper.field_name).each_pair do |group_name, group|
+    future_resolve(parents, query, graph_parent).value!
+  end
+
+  def future_resolve(parents, query, graph_parent)
+    promises = parents.group_by(&grouper.field_name).filter_map do |(group_name, group)|
       next if group_name.nil? || grouper.ignore?(group_name)
 
       match = ->(c) { c.group_name == group_name.to_sym }
       if (sideload = children.values.find(&match))
         duped = remove_invalid_sideloads(sideload.resource, query)
-        sideload.resolve(group, duped, graph_parent)
+        sideload.future_resolve(group, duped, graph_parent)
       else
         err = ::Graphiti::Errors::PolymorphicSideloadChildNotFound
         raise err.new(self, group_name)
       end
     end
+    Concurrent::Promises.zip(*promises)
   end
 
   private

data/lib/graphiti/sideload.rb

@@ -236,7 +236,7 @@ module Graphiti
     end
 
     def load(parents, query, graph_parent)
-      build_resource_proxy(parents, query, graph_parent).to_a
+      future_load(parents, query, graph_parent).value!
     end
 
     # Override in subclass
@@ -286,7 +286,7 @@ module Graphiti
       children.replace(associated) if track_associated
     end
 
-    def resolve(parents, query, graph_parent)
+    def future_resolve(parents, query, graph_parent)
       if single? && parents.length > 1
         raise Errors::SingularSideload.new(self, parents.length)
       end
@@ -300,11 +300,11 @@ module Graphiti
           sideload: self,
           sideload_parent_length: parents.length,
           default_paginate: false
-        sideload_scope.resolve do |sideload_results|
+        sideload_scope.future_resolve do |sideload_results|
           fire_assign(parents, sideload_results)
         end
       else
-        load(parents, query, graph_parent)
+        future_load(parents, query, graph_parent)
       end
     end
 
@@ -368,6 +368,11 @@ module Graphiti
 
     private
 
+    def future_load(parents, query, graph_parent)
+      proxy = build_resource_proxy(parents, query, graph_parent)
+      proxy.respond_to?(:future_resolve_data) ? proxy.future_resolve_data : Concurrent::Promises.fulfilled_future(proxy)
+    end
+
     def blank_query?(params)
       if (filter = params[:filter])
         if filter.values == [""]

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "1.7.9"
+  VERSION = "1.8.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.7.9
+  version: 1.8.0
 platform: ruby
 authors:
 - Lee Richmond
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-16 00:00:00.000000000 Z
+date: 2025-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-serializable
@@ -82,16 +82,22 @@ dependencies:
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement