Add a benchmark for stack trace depth

Author: rmosolgo

Rakefile

@@ -116,6 +116,18 @@ namespace :bench do
     prepare_benchmark
     GraphQLBenchmark.profile_batch_loaders
   end
+
+  desc "Check the memory footprint of a large schema"
+  task :profile_schema_memory_footprint do
+    prepare_benchmark
+    GraphQLBenchmark.profile_schema_memory_footprint
+  end
+
+  desc "Check the depth of the stacktrace during execution"
+  task :profile_stack_depth do
+    prepare_benchmark
+    GraphQLBenchmark.profile_stack_depth
+  end
 end
 
 namespace :test do

benchmark/run.rb

@@ -221,4 +221,116 @@ def self.profile_batch_loaders
 
     report.pretty_print
   end
+
+  def self.profile_schema_memory_footprint
+    schema = nil
+    report = MemoryProfiler.report do
+      query_type = Class.new(GraphQL::Schema::Object) do
+        graphql_name "Query"
+        100.times do |i|
+          type = Class.new(GraphQL::Schema::Object) do
+            graphql_name "Object#{i}"
+            field :f, Integer
+          end
+          field "f#{i}", type
+        end
+      end
+
+      thing_type = Class.new(GraphQL::Schema::Object) do
+        graphql_name "Thing"
+        field :name, String
+      end
+
+      mutation_type = Class.new(GraphQL::Schema::Object) do
+        graphql_name "Mutation"
+        100.times do |i|
+          mutation_class = Class.new(GraphQL::Schema::RelayClassicMutation) do
+            graphql_name "Do#{i}"
+            argument :id, "ID"
+            field :thing, thing_type
+            field :things, thing_type.connection_type
+          end
+          field "f#{i}", mutation: mutation_class
+        end
+      end
+
+      schema = Class.new(GraphQL::Schema) do
+        query(query_type)
+        mutation(mutation_type)
+      end
+    end
+
+    report.pretty_print
+  end
+
+  class StackDepthSchema < GraphQL::Schema
+    class Thing < GraphQL::Schema::Object
+      field :thing, self do
+        argument :lazy, Boolean, default_value: false
+      end
+
+      def thing(lazy:)
+        if lazy
+          -> { :something }
+        else
+          :something
+        end
+      end
+
+      field :stack_trace_depth, Integer do
+        argument :lazy, Boolean, default_value: false
+      end
+
+      def stack_trace_depth(lazy:)
+        if lazy
+          -> { caller.size }
+        else
+          caller.size
+        end
+      end
+    end
+
+    class Query < GraphQL::Schema::Object
+      field :thing, Thing
+
+      def thing
+        :something
+      end
+    end
+
+    query(Query)
+    lazy_resolve(Proc, :call)
+  end
+
+  def self.profile_stack_depth
+    query_str = <<-GRAPHQL
+    query($lazyThing: Boolean!, $lazyStackTrace: Boolean!) {
+      thing {
+        thing(lazy: $lazyThing) {
+          thing(lazy: $lazyThing) {
+            thing(lazy: $lazyThing) {
+              thing(lazy: $lazyThing) {
+                stackTraceDepth(lazy: $lazyStackTrace)
+              }
+            }
+          }
+        }
+      }
+    }
+    GRAPHQL
+
+    very_lazy_res = StackDepthSchema.execute(query_str, variables: { lazyThing: true, lazyStackTrace: true })
+    pp very_lazy_res
+    lazy_res = StackDepthSchema.execute(query_str, variables: { lazyThing: true, lazyStackTrace: false })
+    eager_res = StackDepthSchema.execute(query_str, variables: { lazyThing: false, lazyStackTrace: false })
+    get_depth = ->(result) { result["data"]["thing"]["thing"]["thing"]["thing"]["thing"]["stackTraceDepth"] }
+
+    puts <<~RESULT
+    Result         Depth
+    ---------------------
+    Eager          #{get_depth.call(eager_res)}
+    Lazy           #{get_depth.call(lazy_res)}
+    Very Lazy      #{get_depth.call(very_lazy_res)}
+    RESULT
+  end
 end