diff --git a/Gemfile b/Gemfile
index 08bcb0aca0389db75ad487491c8c94fb39b86774..711a316d1f1b6478b1d6ca31622d0fadd1e43a9a 100644
--- a/Gemfile
+++ b/Gemfile
@@ -100,7 +100,7 @@ gem 'grape-entity', '~> 0.10.0'
 gem 'rack-cors', '~> 1.0.6', require: 'rack/cors'
 
 # GraphQL API
-gem 'graphql', '~> 1.11.10'
+gem 'graphql', '~> 1.13.12'
 gem 'graphiql-rails', '~> 1.8'
 gem 'apollo_upload_server', '~> 2.1.0'
 gem 'graphql-docs', '~> 1.6.0', group: [:development, :test]
diff --git a/Gemfile.lock b/Gemfile.lock
index 527ac45b1010b32d04950a3f8d315224ff5e039e..19cda99e4dca90f46948ba19cb880151db701207 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -581,7 +581,7 @@ GEM
       faraday (>= 1.0)
       faraday_middleware
       graphql-client
-    graphql (1.11.10)
+    graphql (1.13.12)
     graphql-client (0.17.0)
       activesupport (>= 3.0)
       graphql (~> 1.10)
@@ -1526,7 +1526,7 @@ DEPENDENCIES
   grape_logging (~> 1.8)
   graphiql-rails (~> 1.8)
   graphlient (~> 0.5.0)
-  graphql (~> 1.11.10)
+  graphql (~> 1.13.12)
   graphql-docs (~> 1.6.0)
   grpc (~> 1.42.0)
   gssapi
diff --git a/app/graphql/gitlab_schema.rb b/app/graphql/gitlab_schema.rb
index 9b23aa60eab87de715d4ff9dc3d7cfa2cdd3d53f..b399f0490eeeee0581ef44cb7aad32c03d28b1e4 100644
--- a/app/graphql/gitlab_schema.rb
+++ b/app/graphql/gitlab_schema.rb
@@ -14,17 +14,19 @@ class GitlabSchema < GraphQL::Schema
   use Gitlab::Graphql::Tracers::ApplicationContextTracer
   use Gitlab::Graphql::Tracers::MetricsTracer
   use Gitlab::Graphql::Tracers::LoggerTracer
-  use Gitlab::Graphql::GenericTracing # Old tracer which will be removed eventually
+
+  # TODO: Old tracer which will be removed eventually
+  #       See https://gitlab.com/gitlab-org/gitlab/-/issues/345396
+  use Gitlab::Graphql::GenericTracing
   use Gitlab::Graphql::Tracers::TimerTracer
 
   use GraphQL::Subscriptions::ActionCableSubscriptions
-  use GraphQL::Pagination::Connections
   use BatchLoader::GraphQL
   use Gitlab::Graphql::Pagination::Connections
   use Gitlab::Graphql::Timeout, max_seconds: Gitlab.config.gitlab.graphql_timeout
 
-  query_analyzer Gitlab::Graphql::QueryAnalyzers::LoggerAnalyzer.new
-  query_analyzer Gitlab::Graphql::QueryAnalyzers::RecursionAnalyzer.new
+  query_analyzer Gitlab::Graphql::QueryAnalyzers::AST::LoggerAnalyzer
+  query_analyzer Gitlab::Graphql::QueryAnalyzers::AST::RecursionAnalyzer
 
   query Types::QueryType
   mutation Types::MutationType
@@ -49,10 +51,10 @@ def multiplex(queries, **kwargs)
       super(queries, **kwargs)
     end
 
-    def get_type(type_name)
+    def get_type(type_name, context = GraphQL::Query::NullContext)
       type_name = Gitlab::GlobalId::Deprecations.apply_to_graphql_name(type_name)
 
-      super(type_name)
+      super(type_name, context)
     end
 
     def id_from_object(object, _type = nil, _ctx = nil)
@@ -77,8 +79,7 @@ def object_from_id(global_id, ctx = {})
     end
 
     def resolve_type(type, object, ctx = :__undefined__)
-      tc = type.metadata[:type_class]
-      return if tc.respond_to?(:assignable?) && !tc.assignable?(object)
+      return if type.respond_to?(:assignable?) && !type.assignable?(object)
 
       super
     end
@@ -168,14 +169,3 @@ def get_type(type_name)
 end
 
 GitlabSchema.prepend_mod_with('GitlabSchema') # rubocop: disable Cop/InjectEnterpriseEditionModule
-
-# Force the schema to load as a workaround for intermittent errors we
-# see due to a lack of thread safety.
-#
-# TODO: We can remove this workaround when we convert the schema to use
-# the new query interpreter runtime.
-#
-# See:
-# - https://gitlab.com/gitlab-org/gitlab/-/issues/211478
-# - https://gitlab.com/gitlab-org/gitlab/-/issues/210556
-GitlabSchema.graphql_definition
diff --git a/app/graphql/mutations/base_mutation.rb b/app/graphql/mutations/base_mutation.rb
index d57a097a9e2ed61af8f1a665e1be76eec5e23cc4..5f98b222099ce7121588501661bbca2e413bd7cf 100644
--- a/app/graphql/mutations/base_mutation.rb
+++ b/app/graphql/mutations/base_mutation.rb
@@ -39,14 +39,16 @@ def ready?(**args)
       true
     end
 
-    def load_application_object(argument, lookup_as_type, id, context)
-      ::Gitlab::Graphql::Lazy.new { super }.catch(::GraphQL::UnauthorizedError) do |e|
-        Gitlab::ErrorTracking.track_exception(e)
-        # The default behaviour is to abort processing and return nil for the
-        # entire mutation field, but not set any top-level errors. We prefer to
-        # at least say that something went wrong.
-        raise_resource_not_available_error!
-      end
+    def load_application_object(argument, id, context)
+      ::Gitlab::Graphql::Lazy.new { super }
+    end
+
+    def unauthorized_object(error)
+      # The default behavior is to abort processing and return nil for the
+      # entire mutation field, but not set any top-level errors. We prefer to
+      # at least say that something went wrong.
+      Gitlab::ErrorTracking.track_exception(error)
+      raise_resource_not_available_error!
     end
 
     def self.authorizes_object?
diff --git a/app/graphql/types/base_field.rb b/app/graphql/types/base_field.rb
index 83c53e568e91c8b389370188fd5fca80bb5c02ff..6aee9a5c052462863c01fbb8639709000332e69c 100644
--- a/app/graphql/types/base_field.rb
+++ b/app/graphql/types/base_field.rb
@@ -53,6 +53,30 @@ def authorized?(object, args, ctx)
       field_authorized?(object, ctx) && resolver_authorized?(object, ctx)
     end
 
+    # This gets called from the gem's `calculate_complexity` method, allowing us
+    # to ensure our complexity calculation is used even for connections.
+    # This code is actually a copy of the default case in `calculate_complexity`
+    # in `lib/graphql/schema/field.rb`
+    # (https://github.com/rmosolgo/graphql-ruby/blob/master/lib/graphql/schema/field.rb)
+    def complexity_for(child_complexity:, query:, lookahead:)
+      defined_complexity = complexity
+
+      case defined_complexity
+      when Proc
+        arguments = query.arguments_for(lookahead.ast_nodes.first, self)
+
+        if arguments.respond_to?(:keyword_arguments)
+          defined_complexity.call(query.context, arguments.keyword_arguments, child_complexity)
+        else
+          child_complexity
+        end
+      when Numeric
+        defined_complexity + child_complexity
+      else
+        raise("Invalid complexity: #{defined_complexity.inspect} on #{path} (#{inspect})")
+      end
+    end
+
     def base_complexity
       complexity = DEFAULT_COMPLEXITY
       complexity += 1 if calls_gitaly?
diff --git a/app/graphql/types/ci/detailed_status_type.rb b/app/graphql/types/ci/detailed_status_type.rb
index e3413551a3f63d3d6f836fb4cbce535d0f4992bd..3fab040cc0b1f1fcc1e263fe7a9cfcb58f7e5aee 100644
--- a/app/graphql/types/ci/detailed_status_type.rb
+++ b/app/graphql/types/ci/detailed_status_type.rb
@@ -33,7 +33,7 @@ class DetailedStatusType < BaseObject
             method: :status_tooltip
 
       def id(parent:)
-        "#{object.id}-#{parent.object.object.id}"
+        "#{object.id}-#{parent.id}"
       end
 
       def action
diff --git a/app/graphql/types/ci/runner_web_url_edge.rb b/app/graphql/types/ci/runner_web_url_edge.rb
index 035d75c22c67f4f8695f862c7cc366b9cab21291..7dfcd1f3510841e4748c5307ef1616fcc6cf17e7 100644
--- a/app/graphql/types/ci/runner_web_url_edge.rb
+++ b/app/graphql/types/ci/runner_web_url_edge.rb
@@ -4,8 +4,6 @@ module Types
   module Ci
     # rubocop: disable Graphql/AuthorizeTypes
     class RunnerWebUrlEdge < ::Types::BaseEdge
-      include FindClosest
-
       field :edit_url, GraphQL::Types::String, null: true,
             description: 'Web URL of the runner edit page. The value depends on where you put this field in the query. You can use it for projects or groups.',
             extras: [:parent]
@@ -19,19 +17,18 @@ def initialize(node, connection)
         @runner = node.node
       end
 
+      # here parent is a Keyset::Connection
       def edit_url(parent:)
-        runner_url(parent: parent, url_type: :edit_url)
+        runner_url(owner: parent.parent, url_type: :edit_url)
       end
 
       def web_url(parent:)
-        runner_url(parent: parent, url_type: :default)
+        runner_url(owner: parent.parent, url_type: :default)
       end
 
       private
 
-      def runner_url(parent:, url_type: :default)
-        owner = closest_parent([::Types::ProjectType, ::Types::GroupType], parent)
-
+      def runner_url(owner:, url_type: :default)
         # Only ::Group is supported at the moment, future iterations will include ::Project.
         # See https://gitlab.com/gitlab-org/gitlab/-/issues/16338
         case owner
diff --git a/app/graphql/types/ci/status_action_type.rb b/app/graphql/types/ci/status_action_type.rb
index 26ca3c1438aced1b32d29a66f35a5f4ca54d7ae6..c0f61cf49f2f024d4a85fa8b787a5cdcc8697e34 100644
--- a/app/graphql/types/ci/status_action_type.rb
+++ b/app/graphql/types/ci/status_action_type.rb
@@ -21,7 +21,8 @@ class StatusActionType < BaseObject
             description: 'Title for the action, for example: Retry.'
 
       def id(parent:)
-        "#{parent.parent.object.object.class.name}-#{parent.object.object.id}"
+        # parent is a SimpleDelegator
+        "#{parent.subject.class.name}-#{parent.id}"
       end
 
       def action_method
diff --git a/app/graphql/types/concerns/find_closest.rb b/app/graphql/types/concerns/find_closest.rb
deleted file mode 100644
index 3064db19ea0e664062b47ed0f33cb1e0488ea7b8..0000000000000000000000000000000000000000
--- a/app/graphql/types/concerns/find_closest.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module FindClosest
-  # Find the closest node which has any of the given types above this node, and return the domain object
-  def closest_parent(types, parent)
-    while parent
-
-      if types.any? {|type| parent.object.instance_of? type}
-        return parent.object.object
-      else
-        parent = parent.try(:parent)
-      end
-    end
-  end
-end
diff --git a/app/graphql/types/global_id_type.rb b/app/graphql/types/global_id_type.rb
index 6a924c13a3c6cc60cdf8e49e394179e0bf481067..145a5a22460886102ba2e775a7b5fa2a649d5105 100644
--- a/app/graphql/types/global_id_type.rb
+++ b/app/graphql/types/global_id_type.rb
@@ -84,7 +84,8 @@ def self.[](model_class)
         end
 
         define_singleton_method(:suitable?) do |gid|
-          next false if gid.nil?
+          # an argument can be nil, so allow it here
+          next true if gid.nil?
 
           gid.model_name.safe_constantize.present? &&
             gid.model_class.ancestors.include?(model_class)
diff --git a/app/graphql/types/merge_requests/interacts_with_merge_request.rb b/app/graphql/types/merge_requests/interacts_with_merge_request.rb
index 15621ef1472f720d73ba4adb524740ed47fae3da..bef2d39dc5c71af90015c4ded3d5047de2731ff0 100644
--- a/app/graphql/types/merge_requests/interacts_with_merge_request.rb
+++ b/app/graphql/types/merge_requests/interacts_with_merge_request.rb
@@ -5,8 +5,6 @@ module MergeRequests
     module InteractsWithMergeRequest
       extend ActiveSupport::Concern
 
-      include FindClosest
-
       included do
         field :merge_request_interaction,
               type: ::Types::UserMergeRequestInteractionType,
@@ -16,11 +14,9 @@ module InteractsWithMergeRequest
       end
 
       def merge_request_interaction(parent:, id: nil)
-        merge_request = closest_parent([::Types::MergeRequestType], parent)
-
-        return unless merge_request
-
-        Users::MergeRequestInteraction.new(user: object, merge_request: merge_request)
+        # need the connection parent if called from a connection node:
+        parent = parent.parent if parent.try(:field)&.connection?
+        Users::MergeRequestInteraction.new(user: object, merge_request: parent)
       end
     end
   end
diff --git a/app/graphql/types/query_complexity_type.rb b/app/graphql/types/query_complexity_type.rb
index 13b618cf5cea8f814c5697497739c38b7f2799bd..ddcf448c64ad9894491c97c40def2df23d07b9e4 100644
--- a/app/graphql/types/query_complexity_type.rb
+++ b/app/graphql/types/query_complexity_type.rb
@@ -5,7 +5,7 @@ module Types
   class QueryComplexityType < ::Types::BaseObject
     graphql_name 'QueryComplexity'
 
-    ANALYZER = GraphQL::Analysis::QueryComplexity.new { |_query, complexity| complexity }
+    ANALYZER = GraphQL::Analysis::AST::QueryComplexity
 
     alias_method :query, :object
 
@@ -23,7 +23,7 @@ class QueryComplexityType < ::Types::BaseObject
           description: 'GraphQL query complexity score.'
 
     def score
-      ::GraphQL::Analysis.analyze_query(query, [ANALYZER]).first
+      ::GraphQL::Analysis::AST.analyze_query(query, [ANALYZER]).first
     end
   end
   # rubocop: enable Graphql/AuthorizeTypes
diff --git a/app/graphql/types/time_type.rb b/app/graphql/types/time_type.rb
index 2db14953308c560608ea0c7d2afd49548f9e5015..121515c04dbb91f1d785699c1ba18aea64e7efd8 100644
--- a/app/graphql/types/time_type.rb
+++ b/app/graphql/types/time_type.rb
@@ -12,6 +12,9 @@ class TimeType < BaseScalar
     DESC
 
     def self.coerce_input(value, ctx)
+      # arguments can be nil, so don't raise an error
+      return if value.nil?
+
       Time.parse(value)
     rescue ArgumentError, TypeError => e
       raise GraphQL::CoercionError, e.message
diff --git a/ee/app/presenters/iteration_presenter.rb b/ee/app/presenters/iteration_presenter.rb
index 63871c7cc432bf1d82cf2bd5301284ea5982b877..92b47c9479a600245adf4e2a1548c884e276bf1e 100644
--- a/ee/app/presenters/iteration_presenter.rb
+++ b/ee/app/presenters/iteration_presenter.rb
@@ -12,7 +12,7 @@ def iteration_url
   end
 
   def scoped_iteration_path(parent:)
-    parent_object = parent[:parent_object] || iteration.resource_parent
+    parent_object = find_parent_object(parent)
 
     if parent_object.is_a?(Project)
       project_iteration_path(parent_object, iteration.id, only_path: true)
@@ -22,7 +22,7 @@ def scoped_iteration_path(parent:)
   end
 
   def scoped_iteration_url(parent:)
-    parent_object = parent[:parent_object] || iteration.resource_parent
+    parent_object = find_parent_object(parent)
 
     if parent_object.is_a?(Project)
       project_iteration_url(parent_object, iteration.id)
@@ -30,4 +30,11 @@ def scoped_iteration_url(parent:)
       group_iteration_url(parent_object, iteration.id)
     end
   end
+
+  private
+
+  def find_parent_object(parent)
+    (parent.respond_to?(:context) && parent&.context&.fetch(:parent_object)) ||
+      iteration.resource_parent
+  end
 end
diff --git a/ee/spec/graphql/resolvers/compliance_management/merge_requests/compliance_violation_resolver_spec.rb b/ee/spec/graphql/resolvers/compliance_management/merge_requests/compliance_violation_resolver_spec.rb
index 45b7971580e6b4503b1d16882ebd0ec21389af87..179856ccd976ae301a559f89950d8ef24dfbaed4 100644
--- a/ee/spec/graphql/resolvers/compliance_management/merge_requests/compliance_violation_resolver_spec.rb
+++ b/ee/spec/graphql/resolvers/compliance_management/merge_requests/compliance_violation_resolver_spec.rb
@@ -28,7 +28,7 @@
   describe '#resolve' do
     let(:args) { {} }
 
-    subject(:resolve_compliance_violations) { resolve(described_class, obj: group, args: args, ctx: { current_user: current_user }) }
+    subject(:resolve_compliance_violations) { resolve(described_class, obj: group, args: args, ctx: { current_user: current_user }, arg_style: :internal_prepared) }
 
     context 'user is unauthorized' do
       it 'returns nil' do
diff --git a/ee/spec/graphql/resolvers/incident_management/escalation_policies_resolver_spec.rb b/ee/spec/graphql/resolvers/incident_management/escalation_policies_resolver_spec.rb
index 5ae7d4dfd35e5ba0766f4f577accbec084cc4b4b..ea01ae9c2aab76b168533098da0c3aca021cd435 100644
--- a/ee/spec/graphql/resolvers/incident_management/escalation_policies_resolver_spec.rb
+++ b/ee/spec/graphql/resolvers/incident_management/escalation_policies_resolver_spec.rb
@@ -68,6 +68,6 @@
   private
 
   def resolve_escalation_policies(args = {}, context = { current_user: current_user })
-    resolve(resolver, obj: project, args: args, ctx: context)
+    resolve(resolver, obj: project, args: args, ctx: context, arg_style: :internal_prepared)
   end
 end
diff --git a/ee/spec/graphql/resolvers/incident_management/oncall_rotations_resolver_spec.rb b/ee/spec/graphql/resolvers/incident_management/oncall_rotations_resolver_spec.rb
index e83d22b08cfe9569df9708a762fda388aea727eb..6e2253b8aeaa4f3a34fade8ac2a825ec84e5bd60 100644
--- a/ee/spec/graphql/resolvers/incident_management/oncall_rotations_resolver_spec.rb
+++ b/ee/spec/graphql/resolvers/incident_management/oncall_rotations_resolver_spec.rb
@@ -60,6 +60,6 @@
   private
 
   def resolve_oncall_rotations(args = {}, context = { current_user: current_user })
-    resolve(resolver, obj: schedule, args: args, ctx: context)
+    resolve(resolver, obj: schedule, args: args, ctx: context, arg_style: :internal_prepared)
   end
 end
diff --git a/ee/spec/graphql/resolvers/iterations_resolver_spec.rb b/ee/spec/graphql/resolvers/iterations_resolver_spec.rb
index 172e38785ddaaca46934e84d27bacd76961f2f80..ad205ee7c9cd2aeb50c6c892ad9cf871101f53ec 100644
--- a/ee/spec/graphql/resolvers/iterations_resolver_spec.rb
+++ b/ee/spec/graphql/resolvers/iterations_resolver_spec.rb
@@ -27,7 +27,7 @@
       let_it_be(:group) { create(:group, :private) }
 
       def resolve_group_iterations(args = {}, obj = group, context = { current_user: current_user })
-        resolve(described_class, obj: obj, args: args, ctx: context)
+        resolve(described_class, obj: obj, args: args, ctx: context, arg_style: :internal_prepared)
       end
 
       before do
@@ -66,15 +66,14 @@ def resolve_group_iterations(args = {}, obj = group, context = { current_user: c
 
           context 'with search and in parameters' do
             where(:search, :fields_to_search, :expected_iterations) do
-              ''          | []                       | lazy { all_iterations }
-              ''          | [:title]                 | lazy { all_iterations }
-              ''          | [:title, :cadence_title] | lazy { all_iterations }
-              'iteration' | nil                      | lazy { plan_cadence.iterations }
-              'iteration' | []                       | lazy { plan_cadence.iterations }
-              'iteration' | [:title]                 | lazy { plan_cadence.iterations }
-              'iteration' | [:title, :cadence_title] | lazy { plan_cadence.iterations }
-              'plan'      | []                       | lazy { [] }
-              'plan'      | [:cadence_title]         | lazy { plan_cadence.iterations }
+              ''          | []                         | lazy { all_iterations }
+              ''          | ['TITLE']                  | lazy { all_iterations }
+              ''          | %w[TITLE CADENCE_TITLE]    | lazy { all_iterations }
+              'iteration' | []                         | lazy { plan_cadence.iterations }
+              'iteration' | ['TITLE']                  | lazy { plan_cadence.iterations }
+              'iteration' | %w[TITLE CADENCE_TITLE]    | lazy { plan_cadence.iterations }
+              'plan'      | []                         | lazy { [] }
+              'plan'      | ['CADENCE_TITLE']          | lazy { plan_cadence.iterations }
             end
 
             with_them do
@@ -91,8 +90,8 @@ def resolve_group_iterations(args = {}, obj = group, context = { current_user: c
           context "with the deprecated argument 'title' (to be deprecated in 15.4)" do
             [
               { search: "foo" },
-              { in: [:title] },
-              { in: [:cadence_title] }
+              { in: ['TITLE'] },
+              { in: ['CADENCE_TITLE'] }
             ].each do |params|
               it "raises an error when 'title' is used with #{params}" do
                 expect_graphql_error_to_be_created(Gitlab::Graphql::Errors::ArgumentError, "'title' is deprecated in favor of 'search'. Please use 'search'.") do
diff --git a/ee/spec/graphql/resolvers/vulnerabilities_resolver_spec.rb b/ee/spec/graphql/resolvers/vulnerabilities_resolver_spec.rb
index b540d1af958bba17f73baa28485c23e9ad90e8d6..fde7bc5aa33bdef0bc7c41bb3e457a99e833184d 100644
--- a/ee/spec/graphql/resolvers/vulnerabilities_resolver_spec.rb
+++ b/ee/spec/graphql/resolvers/vulnerabilities_resolver_spec.rb
@@ -6,7 +6,7 @@
   include GraphqlHelpers
 
   describe '#resolve' do
-    subject { resolve(described_class, obj: vulnerable, args: params, ctx: { current_user: current_user }) }
+    subject { resolve(described_class, obj: vulnerable, args: params, ctx: { current_user: current_user }, arg_style: :internal_prepared) }
 
     let_it_be_with_reload(:project) { create(:project) }
     let_it_be(:user) { create(:user, security_dashboard_projects: [project]) }
diff --git a/ee/spec/requests/api/graphql/mutations/incident_management/oncall_rotation/create_spec.rb b/ee/spec/requests/api/graphql/mutations/incident_management/oncall_rotation/create_spec.rb
index 08d2f9994f6321baff39a275a979450e559d8488..27a80177b7b3de02cb8e0f0aeb9334d5f054f838 100644
--- a/ee/spec/requests/api/graphql/mutations/incident_management/oncall_rotation/create_spec.rb
+++ b/ee/spec/requests/api/graphql/mutations/incident_management/oncall_rotation/create_spec.rb
@@ -104,9 +104,7 @@
     it 'returns the on-call rotation with errors' do
       post_graphql_mutation(mutation, current_user: current_user)
 
-      expect(graphql_errors).not_to be_empty
-      error = graphql_errors.first.dig('extensions', 'problems', 0, 'explanation')
-      expect(error).to match('Time given is invalid')
+      expect(graphql_errors).to include(a_hash_including('message' => 'Time given is invalid'))
     end
   end
 
@@ -118,9 +116,7 @@
     it 'returns the on-call rotation with errors' do
       post_graphql_mutation(mutation, current_user: current_user)
 
-      expect(graphql_errors).not_to be_empty
-      error = graphql_errors.first.dig('extensions', 'problems', 0, 'explanation')
-      expect(error).to match('Date given is invalid')
+      expect(graphql_errors).to include(a_hash_including('message' => 'Date given is invalid'))
     end
   end
 end
diff --git a/lib/gitlab/graphql/generic_tracing.rb b/lib/gitlab/graphql/generic_tracing.rb
index 936b22d5afa89a88d7d07e92c10ad7fb803b778b..d3de9c714f4d8a97a71bf4bdd33a7c624d9ffe76 100644
--- a/lib/gitlab/graphql/generic_tracing.rb
+++ b/lib/gitlab/graphql/generic_tracing.rb
@@ -23,6 +23,14 @@ def platform_field_key(type, field)
         "#{type.name}.#{field.name}"
       end
 
+      def platform_authorized_key(type)
+        "#{type.graphql_name}.authorized"
+      end
+
+      def platform_resolve_type_key(type)
+        "#{type.graphql_name}.resolve_type"
+      end
+
       def platform_trace(platform_key, key, data, &block)
         tags = { platform_key: platform_key, key: key }
         start = Gitlab::Metrics::System.monotonic_time
diff --git a/lib/gitlab/graphql/present/field_extension.rb b/lib/gitlab/graphql/present/field_extension.rb
index 050a3a276eadf151220f5666460341ae45a76276..bc6d0c6fd35e61f8f20bb79424aa5ea71a4915d2 100644
--- a/lib/gitlab/graphql/present/field_extension.rb
+++ b/lib/gitlab/graphql/present/field_extension.rb
@@ -21,6 +21,7 @@ def resolve(object:, arguments:, context:)
             # TODO: remove this when resolve procs are removed from the
             # graphql-ruby library, and all field instrumentation is removed.
             # See: https://github.com/rmosolgo/graphql-ruby/issues/3385
+            # See: https://gitlab.com/gitlab-org/gitlab/-/issues/363131
             presented = field.owner.try(:present, object, attrs) || object
             yield(presented, arguments)
           end
diff --git a/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer.rb b/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer.rb
new file mode 100644
index 0000000000000000000000000000000000000000..9a7069249ec3a7a92f65c5ec1dfc59d45e0929f2
--- /dev/null
+++ b/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer.rb
@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module Graphql
+    module QueryAnalyzers
+      module AST
+        class LoggerAnalyzer < GraphQL::Analysis::AST::Analyzer
+          COMPLEXITY_ANALYZER = GraphQL::Analysis::AST::QueryComplexity
+          DEPTH_ANALYZER = GraphQL::Analysis::AST::QueryDepth
+          FIELD_USAGE_ANALYZER = GraphQL::Analysis::AST::FieldUsage
+          ALL_ANALYZERS = [COMPLEXITY_ANALYZER, DEPTH_ANALYZER, FIELD_USAGE_ANALYZER].freeze
+
+          def initialize(query)
+            super
+
+            @results = default_initial_values(query).merge({
+              time_started: Gitlab::Metrics::System.monotonic_time
+            })
+          rescue StandardError => e
+            Gitlab::ErrorTracking.track_and_raise_for_dev_exception(e)
+            @results = default_initial_values(query_or_multiplex)
+          end
+
+          def result
+            complexity, depth, field_usages =
+              GraphQL::Analysis::AST.analyze_query(@subject, ALL_ANALYZERS, multiplex_analyzers: [])
+
+            results[:depth] = depth
+            results[:complexity] = complexity
+            # This duration is not the execution time of the
+            # query but the execution time of the analyzer.
+            results[:duration_s] = duration(results[:time_started])
+            results[:used_fields] = field_usages[:used_fields]
+            results[:used_deprecated_fields] = field_usages[:used_deprecated_fields]
+
+            push_to_request_store(results)
+
+            # This gl_analysis is included in the tracer log
+            query.context[:gl_analysis] = results.except!(:time_started, :query)
+          rescue StandardError => e
+            Gitlab::ErrorTracking.track_and_raise_for_dev_exception(e)
+          end
+
+          private
+
+          attr_reader :results
+
+          def push_to_request_store(results)
+            query = @subject
+
+            # TODO: This RequestStore management is used to handle setting request wide metadata
+            # to improve preexisting logging. We should handle this either with ApplicationContext
+            # or in a separate tracer.
+            # https://gitlab.com/gitlab-org/gitlab/-/issues/343802
+
+            RequestStore.store[:graphql_logs] ||= []
+            RequestStore.store[:graphql_logs] << results.except(:time_started, :duration_s).merge({
+              variables: process_variables(query.provided_variables),
+              operation_name: query.operation_name
+            })
+          end
+
+          def process_variables(variables)
+            filtered_variables = filter_sensitive_variables(variables)
+            filtered_variables.try(:to_s) || filtered_variables
+          end
+
+          def filter_sensitive_variables(variables)
+            ActiveSupport::ParameterFilter
+              .new(::Rails.application.config.filter_parameters)
+              .filter(variables)
+          end
+
+          def duration(time_started)
+            Gitlab::Metrics::System.monotonic_time - time_started
+          end
+
+          def default_initial_values(query)
+            {
+              time_started: Gitlab::Metrics::System.monotonic_time,
+              duration_s: nil
+            }
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/graphql/query_analyzers/ast/recursion_analyzer.rb b/lib/gitlab/graphql/query_analyzers/ast/recursion_analyzer.rb
new file mode 100644
index 0000000000000000000000000000000000000000..4e90e4c912f3e26987d2016af6efd2dbe107875d
--- /dev/null
+++ b/lib/gitlab/graphql/query_analyzers/ast/recursion_analyzer.rb
@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Recursive queries, with relatively low effort, can quickly spiral out of control exponentially
+# and may not be picked up by depth and complexity alone.
+module Gitlab
+  module Graphql
+    module QueryAnalyzers
+      module AST
+        class RecursionAnalyzer < GraphQL::Analysis::AST::Analyzer
+          IGNORED_FIELDS = %w(node edges nodes ofType).freeze
+          RECURSION_THRESHOLD = 2
+
+          def initialize(query)
+            super
+
+            @node_visits = {}
+            @recurring_fields = {}
+          end
+
+          def on_enter_field(node, _parent, visitor)
+            return if skip_node?(node, visitor)
+
+            node_name = node.name
+            node_visits[node_name] ||= 0
+            node_visits[node_name] += 1
+
+            times_encountered = @node_visits[node_name]
+            recurring_fields[node_name] = times_encountered if recursion_too_deep?(node_name, times_encountered)
+          end
+
+          # Visitors are all defined on the AST::Analyzer base class
+          # We override them for custom analyzers.
+          def on_leave_field(node, _parent, visitor)
+            return if skip_node?(node, visitor)
+
+            node_name = node.name
+            node_visits[node_name] ||= 0
+            node_visits[node_name] -= 1
+          end
+
+          def result
+            @recurring_fields = @recurring_fields.select { |k, v| recursion_too_deep?(k, v) }
+
+            if @recurring_fields.any?
+              GraphQL::AnalysisError.new(<<~MSG)
+                Recursive query - too many of fields '#{@recurring_fields}' detected
+                in single branch of the query")
+              MSG
+            end
+          end
+
+          private
+
+          attr_reader :node_visits, :recurring_fields
+
+          def recursion_too_deep?(node_name, times_encountered)
+            return if IGNORED_FIELDS.include?(node_name)
+
+            times_encountered > recursion_threshold
+          end
+
+          def skip_node?(node, visitor)
+            # We don't want to count skipped fields or fields
+            # inside fragment definitions
+            return false if visitor.skipping? || visitor.visiting_fragment_definition?
+
+            !node.is_a?(GraphQL::Language::Nodes::Field) || node.selections.empty?
+          end
+
+          # separated into a method for use in allow_high_graphql_recursion
+          def recursion_threshold
+            RECURSION_THRESHOLD
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/graphql/query_analyzers/logger_analyzer.rb b/lib/gitlab/graphql/query_analyzers/logger_analyzer.rb
deleted file mode 100644
index 207324e73bd892ab91fba00b7f496a57e3da4dcf..0000000000000000000000000000000000000000
--- a/lib/gitlab/graphql/query_analyzers/logger_analyzer.rb
+++ /dev/null
@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Gitlab
-  module Graphql
-    module QueryAnalyzers
-      class LoggerAnalyzer
-        COMPLEXITY_ANALYZER = GraphQL::Analysis::QueryComplexity.new { |query, complexity_value| complexity_value }
-        DEPTH_ANALYZER = GraphQL::Analysis::QueryDepth.new { |query, depth_value| depth_value }
-        FIELD_USAGE_ANALYZER = GraphQL::Analysis::FieldUsage.new { |query, used_fields, used_deprecated_fields| [used_fields, used_deprecated_fields] }
-        ALL_ANALYZERS = [COMPLEXITY_ANALYZER, DEPTH_ANALYZER, FIELD_USAGE_ANALYZER].freeze
-
-        def initial_value(query)
-          {
-            time_started: Gitlab::Metrics::System.monotonic_time,
-            query: query
-          }
-        end
-
-        def call(memo, *)
-          memo
-        end
-
-        def final_value(memo)
-          return if memo.nil?
-
-          query = memo[:query]
-          complexity, depth, field_usages = GraphQL::Analysis.analyze_query(query, ALL_ANALYZERS)
-
-          memo[:depth] = depth
-          memo[:complexity] = complexity
-          # This duration is not the execution time of the
-          # query but the execution time of the analyzer.
-          memo[:duration_s] = duration(memo[:time_started])
-          memo[:used_fields] = field_usages.first
-          memo[:used_deprecated_fields] = field_usages.second
-
-          push_to_request_store(memo)
-
-          # This gl_analysis is included in the tracer log
-          query.context[:gl_analysis] = memo.except!(:time_started, :query)
-        rescue StandardError => e
-          Gitlab::ErrorTracking.track_and_raise_for_dev_exception(e)
-        end
-
-        private
-
-        def push_to_request_store(memo)
-          query = memo[:query]
-
-          # TODO: This RequestStore management is used to handle setting request wide metadata
-          # to improve preexisting logging. We should handle this either with ApplicationContext
-          # or in a separate tracer.
-          # https://gitlab.com/gitlab-org/gitlab/-/issues/343802
-
-          RequestStore.store[:graphql_logs] ||= []
-          RequestStore.store[:graphql_logs] << memo.except(:time_started, :duration_s, :query).merge({
-            variables: process_variables(query.provided_variables),
-            operation_name: query.operation_name
-          })
-        end
-
-        def process_variables(variables)
-          filtered_variables = filter_sensitive_variables(variables)
-
-          if filtered_variables.respond_to?(:to_s)
-            filtered_variables.to_s
-          else
-            filtered_variables
-          end
-        end
-
-        def filter_sensitive_variables(variables)
-          ActiveSupport::ParameterFilter
-            .new(::Rails.application.config.filter_parameters)
-            .filter(variables)
-        end
-
-        def duration(time_started)
-          Gitlab::Metrics::System.monotonic_time - time_started
-        end
-      end
-    end
-  end
-end
diff --git a/lib/gitlab/graphql/query_analyzers/recursion_analyzer.rb b/lib/gitlab/graphql/query_analyzers/recursion_analyzer.rb
deleted file mode 100644
index 79a7104a2fff8a7f70fabafc6d4046b905cff247..0000000000000000000000000000000000000000
--- a/lib/gitlab/graphql/query_analyzers/recursion_analyzer.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-# Recursive queries, with relatively low effort, can quickly spiral out of control exponentially
-# and may not be picked up by depth and complexity alone.
-module Gitlab
-  module Graphql
-    module QueryAnalyzers
-      class RecursionAnalyzer
-        IGNORED_FIELDS = %w(node edges nodes ofType).freeze
-        RECURSION_THRESHOLD = 2
-
-        def initial_value(query)
-          {
-              recurring_fields: {}
-          }
-        end
-
-        def call(memo, visit_type, irep_node)
-          return memo if skip_node?(irep_node)
-
-          node_name = irep_node.ast_node.name
-          times_encountered = memo[node_name] || 0
-
-          if visit_type == :enter
-            times_encountered += 1
-            memo[:recurring_fields][node_name] = times_encountered if recursion_too_deep?(node_name, times_encountered)
-          else
-            times_encountered -= 1
-          end
-
-          memo[node_name] = times_encountered
-          memo
-        end
-
-        def final_value(memo)
-          recurring_fields = memo[:recurring_fields]
-          recurring_fields = recurring_fields.select { |k, v| recursion_too_deep?(k, v) }
-          if recurring_fields.any?
-            GraphQL::AnalysisError.new("Recursive query - too many of fields '#{recurring_fields}' detected in single branch of the query")
-          end
-        end
-
-        private
-
-        def recursion_too_deep?(node_name, times_encountered)
-          return if IGNORED_FIELDS.include?(node_name)
-
-          times_encountered > recursion_threshold
-        end
-
-        def skip_node?(irep_node)
-          ast_node = irep_node.ast_node
-          !ast_node.is_a?(GraphQL::Language::Nodes::Field) || ast_node.selections.empty?
-        end
-
-        def recursion_threshold
-          RECURSION_THRESHOLD
-        end
-      end
-    end
-  end
-end
diff --git a/spec/controllers/graphql_controller_spec.rb b/spec/controllers/graphql_controller_spec.rb
index 0818dce776dfddb1b8d1d16c6408d5a51a9becea..e85f5b7a972ef39c2fd6410b5e7b495e2d8a6517 100644
--- a/spec/controllers/graphql_controller_spec.rb
+++ b/spec/controllers/graphql_controller_spec.rb
@@ -5,6 +5,9 @@
 RSpec.describe GraphqlController do
   include GraphqlHelpers
 
+  # two days is enough to make timezones irrelevant
+  let_it_be(:last_activity_on) { 2.days.ago.to_date }
+
   before do
     stub_feature_flags(graphql: true)
   end
@@ -40,7 +43,7 @@
 
   describe 'POST #execute' do
     context 'when user is logged in' do
-      let(:user) { create(:user, last_activity_on: Date.yesterday) }
+      let(:user) { create(:user, last_activity_on: last_activity_on) }
 
       before do
         sign_in(user)
@@ -161,7 +164,7 @@
     end
 
     context 'when 2FA is required for the user' do
-      let(:user) { create(:user, last_activity_on: Date.yesterday) }
+      let(:user) { create(:user, last_activity_on: last_activity_on) }
 
       before do
         group = create(:group, require_two_factor_authentication: true)
@@ -186,14 +189,14 @@
     end
 
     context 'when user uses an API token' do
-      let(:user) { create(:user, last_activity_on: Date.yesterday) }
+      let(:user) { create(:user, last_activity_on: last_activity_on) }
       let(:token) { create(:personal_access_token, user: user, scopes: [:api]) }
       let(:query) { '{ __typename }' }
 
       subject { post :execute, params: { query: query, access_token: token.token } }
 
       context 'when the user is a project bot' do
-        let(:user) { create(:user, :project_bot, last_activity_on: Date.yesterday) }
+        let(:user) { create(:user, :project_bot, last_activity_on: last_activity_on) }
 
         it 'updates the users last_activity_on field' do
           expect { subject }.to change { user.reload.last_activity_on }
diff --git a/spec/graphql/gitlab_schema_spec.rb b/spec/graphql/gitlab_schema_spec.rb
index 02c686af6888ffb0d20df89af9b0f7dc40ff7b4f..60b3edfc2791b407c0732386c6e6ffc604a45cf0 100644
--- a/spec/graphql/gitlab_schema_spec.rb
+++ b/spec/graphql/gitlab_schema_spec.rb
@@ -4,15 +4,16 @@
 
 RSpec.describe GitlabSchema do
   let_it_be(:connections) { GitlabSchema.connections.all_wrappers }
+  let_it_be(:tracers) { described_class.tracers }
 
   let(:user) { build :user }
 
   it 'uses batch loading' do
-    expect(field_instrumenters).to include(BatchLoader::GraphQL)
+    expect(tracers).to include(BatchLoader::GraphQL)
   end
 
   it 'enables the generic instrumenter' do
-    expect(field_instrumenters).to include(instance_of(::Gitlab::Graphql::GenericTracing))
+    expect(tracers).to include(instance_of(::Gitlab::Graphql::GenericTracing))
   end
 
   it 'has the base mutation' do
@@ -219,6 +220,8 @@ def initialize(id)
             badField
             veryBadField
             alsoNotAGoodField
+            yetAnotherBadField
+            andYetAnother
           }
         }
       GQL
@@ -308,8 +311,4 @@ def initialize(id)
       end
     end
   end
-
-  def field_instrumenters
-    described_class.instrumenters[:field] + described_class.instrumenters[:field_after_built_ins]
-  end
 end
diff --git a/spec/graphql/mutations/boards/issues/issue_move_list_spec.rb b/spec/graphql/mutations/boards/issues/issue_move_list_spec.rb
index b9d19b68001ed21ec6da8d62c24f07a1307b5da3..10aed8a1f009d807e90ddeb2739caab7f3ecd6f5 100644
--- a/spec/graphql/mutations/boards/issues/issue_move_list_spec.rb
+++ b/spec/graphql/mutations/boards/issues/issue_move_list_spec.rb
@@ -67,7 +67,7 @@
       end
 
       it 'raises an error' do
-        expect { subject }.to raise_error(::GraphQL::LoadApplicationObjectFailedError)
+        expect { subject }.to raise_error(::GraphQL::CoercionError, "\"#{params[:board_id]}\" does not represent an instance of Board")
       end
     end
 
diff --git a/spec/graphql/mutations/branches/create_spec.rb b/spec/graphql/mutations/branches/create_spec.rb
index 9b92753a349176b6268104f6bb242bc713c41cf2..5e9b914d87cb54594e64e28675d978a52cee652c 100644
--- a/spec/graphql/mutations/branches/create_spec.rb
+++ b/spec/graphql/mutations/branches/create_spec.rb
@@ -3,6 +3,8 @@
 require 'spec_helper'
 
 RSpec.describe Mutations::Branches::Create do
+  include GraphqlHelpers
+
   subject(:mutation) { described_class.new(object: nil, context: context, field: nil) }
 
   let_it_be(:project) { create(:project, :public, :repository) }
@@ -10,7 +12,7 @@
 
   let(:context) do
     GraphQL::Query::Context.new(
-      query: double('query', schema: nil),
+      query: query_double(schema: nil),
       values: { current_user: user },
       object: nil
     )
diff --git a/spec/graphql/mutations/clusters/agent_tokens/create_spec.rb b/spec/graphql/mutations/clusters/agent_tokens/create_spec.rb
index f60aa16c68c9c20e0842b8b75df0bb647fdfccd6..7998be19c2007cd1ce232b723290f752e6ada838 100644
--- a/spec/graphql/mutations/clusters/agent_tokens/create_spec.rb
+++ b/spec/graphql/mutations/clusters/agent_tokens/create_spec.rb
@@ -3,6 +3,8 @@
 require 'spec_helper'
 
 RSpec.describe Mutations::Clusters::AgentTokens::Create do
+  include GraphqlHelpers
+
   subject(:mutation) { described_class.new(object: nil, context: context, field: nil) }
 
   let_it_be(:cluster_agent) { create(:cluster_agent) }
@@ -10,7 +12,7 @@
 
   let(:context) do
     GraphQL::Query::Context.new(
-      query: double('query', schema: nil), # rubocop:disable RSpec/VerifiedDoubles
+      query: query_double(schema: nil), # rubocop:disable RSpec/VerifiedDoubles
       values: { current_user: user },
       object: nil
     )
diff --git a/spec/graphql/mutations/clusters/agents/create_spec.rb b/spec/graphql/mutations/clusters/agents/create_spec.rb
index 62498357d681c0dce177f37f83973564a04bd920..e2c04254ed83014fcfede92c49e7b076be8634f9 100644
--- a/spec/graphql/mutations/clusters/agents/create_spec.rb
+++ b/spec/graphql/mutations/clusters/agents/create_spec.rb
@@ -3,13 +3,15 @@
 require 'spec_helper'
 
 RSpec.describe Mutations::Clusters::Agents::Create do
+  include GraphqlHelpers
+
   subject(:mutation) { described_class.new(object: nil, context: context, field: nil) }
 
   let(:project) { create(:project, :public, :repository) }
   let(:user) { create(:user) }
   let(:context) do
     GraphQL::Query::Context.new(
-      query: double('query', schema: nil), # rubocop:disable RSpec/VerifiedDoubles
+      query: query_double(schema: nil), # rubocop:disable RSpec/VerifiedDoubles
       values: { current_user: user },
       object: nil
     )
diff --git a/spec/graphql/mutations/clusters/agents/delete_spec.rb b/spec/graphql/mutations/clusters/agents/delete_spec.rb
index ab01a2d93b8bfd8ed060079c4d58695018310872..c3a2c0dcbb4bfe7a59a4a52fb7f214efc464de6e 100644
--- a/spec/graphql/mutations/clusters/agents/delete_spec.rb
+++ b/spec/graphql/mutations/clusters/agents/delete_spec.rb
@@ -3,6 +3,8 @@
 require 'spec_helper'
 
 RSpec.describe Mutations::Clusters::Agents::Delete do
+  include GraphqlHelpers
+
   subject(:mutation) { described_class.new(object: nil, context: context, field: nil) }
 
   let(:cluster_agent) { create(:cluster_agent) }
@@ -10,7 +12,7 @@
   let(:user) { create(:user) }
   let(:context) do
     GraphQL::Query::Context.new(
-      query: double('query', schema: nil), # rubocop:disable RSpec/VerifiedDoubles
+      query: query_double(schema: nil), # rubocop:disable RSpec/VerifiedDoubles
       values: { current_user: user },
       object: nil
     )
diff --git a/spec/graphql/mutations/commits/create_spec.rb b/spec/graphql/mutations/commits/create_spec.rb
index 456f6dc03f7e20256f1fb2301d20febc95c51e4f..9fc9c731b969fb54d1827c7b0c9f226665ab79ed 100644
--- a/spec/graphql/mutations/commits/create_spec.rb
+++ b/spec/graphql/mutations/commits/create_spec.rb
@@ -3,6 +3,8 @@
 require 'spec_helper'
 
 RSpec.describe Mutations::Commits::Create do
+  include GraphqlHelpers
+
   subject(:mutation) { described_class.new(object: nil, context: context, field: nil) }
 
   let_it_be(:user) { create(:user) }
@@ -10,7 +12,7 @@
 
   let(:context) do
     GraphQL::Query::Context.new(
-      query: double('query', schema: nil), # rubocop:disable RSpec/VerifiedDoubles
+      query: query_double(schema: nil), # rubocop:disable RSpec/VerifiedDoubles
       values: { current_user: user },
       object: nil
     )
diff --git a/spec/graphql/resolvers/incident_management/timeline_events_resolver_spec.rb b/spec/graphql/resolvers/incident_management/timeline_events_resolver_spec.rb
index 6604141abfe919cb1198a8b5b4e3ec055aa5ffe9..bd41af533cee1c146fc42298e69f7d3edce2749f 100644
--- a/spec/graphql/resolvers/incident_management/timeline_events_resolver_spec.rb
+++ b/spec/graphql/resolvers/incident_management/timeline_events_resolver_spec.rb
@@ -66,6 +66,6 @@
   private
 
   def resolve_timeline_events(args = {}, context = { current_user: current_user })
-    resolve(resolver, obj: incident, args: args, ctx: context)
+    resolve(resolver, obj: incident, args: args, ctx: context, arg_style: :internal_prepared)
   end
 end
diff --git a/spec/graphql/subscriptions/issuable_updated_spec.rb b/spec/graphql/subscriptions/issuable_updated_spec.rb
index 0b8fcf675130142f9232f79df937154ee32b4e94..bc640e9e3c447851524c5f3eacb0ea69d12cb116 100644
--- a/spec/graphql/subscriptions/issuable_updated_spec.rb
+++ b/spec/graphql/subscriptions/issuable_updated_spec.rb
@@ -52,7 +52,8 @@
         let(:current_user) { unauthorized_user }
 
         it 'unsubscribes the user' do
-          expect { subject }.to throw_symbol(:graphql_subscription_unsubscribed)
+          # GraphQL::Execution::Execute::Skip is returned when unsubscribed
+          expect(subject).to be_an(GraphQL::Execution::Execute::Skip)
         end
       end
     end
diff --git a/spec/graphql/types/base_edge_spec.rb b/spec/graphql/types/base_edge_spec.rb
index 3afb42021734196c2e560f9220f18cf002de1288..b02ccbaffef875e68bd4aba5fab6e0f9e5ead2af 100644
--- a/spec/graphql/types/base_edge_spec.rb
+++ b/spec/graphql/types/base_edge_spec.rb
@@ -25,7 +25,6 @@ def proof_of_admin_rights
 
     Class.new(GraphQL::Schema) do
       lazy_resolve ::Gitlab::Graphql::Lazy, :force
-      use ::GraphQL::Pagination::Connections
       use ::Gitlab::Graphql::Pagination::Connections
 
       query(Class.new(::Types::BaseObject) do
diff --git a/spec/graphql/types/base_object_spec.rb b/spec/graphql/types/base_object_spec.rb
index 45dc885ecba799841e3963dd36a32e51ca978600..3c42c708187b7ef7973392676bcfe39357d194f4 100644
--- a/spec/graphql/types/base_object_spec.rb
+++ b/spec/graphql/types/base_object_spec.rb
@@ -137,7 +137,6 @@ def polymorphic_object(value)
 
       Class.new(GraphQL::Schema) do
         lazy_resolve ::Gitlab::Graphql::Lazy, :force
-        use ::GraphQL::Pagination::Connections
         use ::Gitlab::Graphql::Pagination::Connections
 
         query(Class.new(::Types::BaseObject) do
diff --git a/spec/graphql/types/ci/detailed_status_type_spec.rb b/spec/graphql/types/ci/detailed_status_type_spec.rb
index 5ed79b73a4777216c852b7ecf225e67cfa99ef10..0bcb58202ad965b934749e76a107d6a30c6453e8 100644
--- a/spec/graphql/types/ci/detailed_status_type_spec.rb
+++ b/spec/graphql/types/ci/detailed_status_type_spec.rb
@@ -17,12 +17,10 @@
 
   describe 'id field' do
     it 'correctly renders the field' do
-      parent_object = double(:parent_object, object: stage)
-      parent = double(:parent, object: parent_object)
       status = stage.detailed_status(stage.pipeline.user)
       expected_id = "#{status.id}-#{stage.id}"
 
-      expect(resolve_field('id', status, extras: { parent: parent })).to eq(expected_id)
+      expect(resolve_field('id', status, extras: { parent: stage })).to eq(expected_id)
     end
   end
 
diff --git a/spec/graphql/types/ci/status_action_type_spec.rb b/spec/graphql/types/ci/status_action_type_spec.rb
index ab7dee3dd1141294537e6ca0548a9fca2ba0a180..1ea31416ef5e7a05e360a037b3349cd0699701e9 100644
--- a/spec/graphql/types/ci/status_action_type_spec.rb
+++ b/spec/graphql/types/ci/status_action_type_spec.rb
@@ -25,15 +25,9 @@
       stage = build(:ci_stage_entity, status: :skipped)
       status = stage.detailed_status(stage.pipeline.user)
 
-      grandparent_object = double(:grandparent_object, object: stage)
-      parent_object = double(:parent_object, object: status)
-
-      grandparent = double(:parent, object: grandparent_object)
-      parent = double(:parent, object: parent_object, parent: grandparent)
-
       expected_id = "#{stage.class.name}-#{status.id}"
 
-      expect(resolve_field('id', status, extras: { parent: parent })).to eq(expected_id)
+      expect(resolve_field('id', status, extras: { parent: status })).to eq(expected_id)
     end
   end
 end
diff --git a/spec/graphql/types/time_type_spec.rb b/spec/graphql/types/time_type_spec.rb
index 3b0d257e1d7f6aba3e7f46fd60cde4f781a0e5db..367a2371694457707105d1efb653650edba1adbd 100644
--- a/spec/graphql/types/time_type_spec.rb
+++ b/spec/graphql/types/time_type_spec.rb
@@ -21,8 +21,7 @@
       .to raise_error(GraphQL::CoercionError)
   end
 
-  it 'rejects nil' do
-    expect { described_class.coerce_isolated_input(nil) }
-      .to raise_error(GraphQL::CoercionError)
+  it 'allows nil' do
+    expect(described_class.coerce_isolated_input(nil)).to be_nil
   end
 end
diff --git a/spec/graphql/types/work_items/widget_interface_spec.rb b/spec/graphql/types/work_items/widget_interface_spec.rb
index 63d7782df28f9811208db6ce4534daf6cd60ec2d..6cb9ff65a4ff65b93b500df9b9b11407c78085c7 100644
--- a/spec/graphql/types/work_items/widget_interface_spec.rb
+++ b/spec/graphql/types/work_items/widget_interface_spec.rb
@@ -21,9 +21,8 @@
     it 'raises an error for an unknown type' do
       project = build(:project)
 
-      expect_graphql_error_to_be_created("Unknown GraphQL type for widget #{project}") do
-        described_class.resolve_type(project, {})
-      end
+      expect { described_class.resolve_type(project, {}) }
+        .to raise_error("Unknown GraphQL type for widget #{project}")
     end
   end
 end
diff --git a/spec/lib/gitlab/graphql/markdown_field_spec.rb b/spec/lib/gitlab/graphql/markdown_field_spec.rb
index a73eba1e9db2c57fe73f188d4a52eeef9ce34327..4d38941a61801e98286146e1e299a7134b3f2b26 100644
--- a/spec/lib/gitlab/graphql/markdown_field_spec.rb
+++ b/spec/lib/gitlab/graphql/markdown_field_spec.rb
@@ -22,13 +22,6 @@
         expect { class_with_markdown_field(:test_html, null: true, resolver: 'not really') }
           .to raise_error(expected_error)
       end
-
-      # TODO: remove as part of https://gitlab.com/gitlab-org/gitlab/-/merge_requests/27536
-      # so that until that time, the developer check is there
-      it 'raises when passing a resolve block' do
-        expect { class_with_markdown_field(:test_html, null: true, resolve: -> (_, _, _) { 'not really' } ) }
-          .to raise_error(expected_error)
-      end
     end
 
     context 'resolving markdown' do
diff --git a/spec/lib/gitlab/graphql/negatable_arguments_spec.rb b/spec/lib/gitlab/graphql/negatable_arguments_spec.rb
index 71ef75836c0e0fc63a52a6a7f1f2250a2fe5ff36..04ee1c1b820727009d866643cf68bb4fd33d54f8 100644
--- a/spec/lib/gitlab/graphql/negatable_arguments_spec.rb
+++ b/spec/lib/gitlab/graphql/negatable_arguments_spec.rb
@@ -25,7 +25,9 @@
       expect(test_resolver.arguments['not'].type.arguments.keys).to match_array(['foo'])
     end
 
-    it 'defines all arguments passed as block even if called multiple times' do
+    # TODO: suffers from the `DuplicateNamesError` error. skip until we upgrade
+    # to the graphql 2.0 gem https://gitlab.com/gitlab-org/gitlab/-/issues/363131
+    xit 'defines all arguments passed as block even if called multiple times' do
       test_resolver.negated do
         argument :foo, GraphQL::Types::String, required: false
       end
diff --git a/spec/lib/gitlab/graphql/present/field_extension_spec.rb b/spec/lib/gitlab/graphql/present/field_extension_spec.rb
index 5f0f444e0bb655596d03d4e44695663509697c37..49992d7b71f4b2d07a88d7ad3d5ca5fa28792e25 100644
--- a/spec/lib/gitlab/graphql/present/field_extension_spec.rb
+++ b/spec/lib/gitlab/graphql/present/field_extension_spec.rb
@@ -143,23 +143,6 @@ def value
       it_behaves_like 'calling the presenter method'
     end
 
-    # This is exercised here using an explicit `resolve:` proc, but
-    # @resolver_proc values are used in field instrumentation as well.
-    context 'when the field uses a resolve proc' do
-      let(:presenter) { base_presenter }
-      let(:field) do
-        ::Types::BaseField.new(
-          name: field_name,
-          type: GraphQL::Types::String,
-          null: true,
-          owner: owner,
-          resolve: ->(obj, args, ctx) { 'Hello from a proc' }
-        )
-      end
-
-      specify { expect(resolve_value).to eq 'Hello from a proc' }
-    end
-
     context 'when the presenter provides a new method' do
       def presenter
         Class.new(base_presenter) do
diff --git a/spec/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer_spec.rb b/spec/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer_spec.rb
new file mode 100644
index 0000000000000000000000000000000000000000..a5274d49fdbced9b58fa299b3beb9c640a7b8e60
--- /dev/null
+++ b/spec/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer_spec.rb
@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Gitlab::Graphql::QueryAnalyzers::AST::LoggerAnalyzer do
+  let(:query) { GraphQL::Query.new(GitlabSchema, document: document, context: {}, variables: { body: 'some note' }) }
+  let(:document) do
+    GraphQL.parse <<-GRAPHQL
+      mutation createNote($body: String!) {
+        createNote(input: {noteableId: "gid://gitlab/Noteable/1", body: $body}) {
+          note {
+            id
+          }
+        }
+      }
+    GRAPHQL
+  end
+
+  describe '#result' do
+    let(:monotonic_time_before) { 42 }
+    let(:monotonic_time_after) { 500 }
+    let(:monotonic_time_duration) { monotonic_time_after - monotonic_time_before }
+
+    before do
+      RequestStore.store[:graphql_logs] = nil
+
+      allow(Gitlab::Metrics::System).to receive(:monotonic_time)
+        .and_return(monotonic_time_before, monotonic_time_before,
+                    monotonic_time_before, monotonic_time_before,
+                    monotonic_time_after)
+    end
+
+    it 'returns the complexity, depth, duration, etc' do
+      results = GraphQL::Analysis::AST.analyze_query(query, [described_class], multiplex_analyzers: [])
+      result = results.first
+
+      expect(result[:duration_s]).to eq monotonic_time_duration
+      expect(result[:depth]).to eq 3
+      expect(result[:complexity]).to eq 3
+      expect(result[:used_fields]).to eq ['Note.id', 'CreateNotePayload.note', 'Mutation.createNote']
+      expect(result[:used_deprecated_fields]).to eq []
+
+      request = result.except(:duration_s).merge({
+        operation_name: 'createNote',
+        variables: { body: "[FILTERED]" }.to_s
+      })
+
+      expect(RequestStore.store[:graphql_logs]).to match([request])
+    end
+  end
+end
diff --git a/spec/lib/gitlab/graphql/query_analyzers/ast/recursion_analyzer_spec.rb b/spec/lib/gitlab/graphql/query_analyzers/ast/recursion_analyzer_spec.rb
new file mode 100644
index 0000000000000000000000000000000000000000..997fb129f424c10983ef6bda145373e7fb5b1cde
--- /dev/null
+++ b/spec/lib/gitlab/graphql/query_analyzers/ast/recursion_analyzer_spec.rb
@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Gitlab::Graphql::QueryAnalyzers::AST::RecursionAnalyzer do
+  let(:query) { GraphQL::Query.new(GitlabSchema, document: document, context: {}, variables: { body: 'some note' }) }
+
+  context 'when recursion threshold not exceeded' do
+    let(:document) do
+      GraphQL.parse <<-GRAPHQL
+          query recurse {
+            group(fullPath: "h5bp") {
+              projects {
+                nodes {
+                  name
+                  group {
+                    projects {
+                      nodes {
+                        name
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+      GRAPHQL
+    end
+
+    it 'returns the complexity, depth, duration, etc' do
+      result = GraphQL::Analysis::AST.analyze_query(query, [described_class], multiplex_analyzers: [])
+
+      expect(result.first).to be_nil
+    end
+  end
+
+  context 'when recursion threshold exceeded' do
+    let(:document) do
+      GraphQL.parse <<-GRAPHQL
+          query recurse {
+            group(fullPath: "h5bp") {
+              projects {
+                nodes {
+                  name
+                  group {
+                    projects {
+                      nodes {
+                        name
+                        group {
+                          projects {
+                            nodes {
+                              name
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+      GRAPHQL
+    end
+
+    it 'returns error' do
+      result = GraphQL::Analysis::AST.analyze_query(query, [described_class], multiplex_analyzers: [])
+
+      expect(result.first.is_a?(GraphQL::AnalysisError)).to be_truthy
+    end
+  end
+end
diff --git a/spec/lib/gitlab/graphql/query_analyzers/logger_analyzer_spec.rb b/spec/lib/gitlab/graphql/query_analyzers/logger_analyzer_spec.rb
deleted file mode 100644
index dee8f9e3c64a65afdf7a8f4812fdbdbded49a6cf..0000000000000000000000000000000000000000
--- a/spec/lib/gitlab/graphql/query_analyzers/logger_analyzer_spec.rb
+++ /dev/null
@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Gitlab::Graphql::QueryAnalyzers::LoggerAnalyzer do
-  let(:initial_value) { analyzer.initial_value(query) }
-  let(:analyzer) { described_class.new }
-  let(:query) { GraphQL::Query.new(GitlabSchema, document: document, context: {}, variables: { body: "some note" }) }
-  let(:document) do
-    GraphQL.parse <<-GRAPHQL
-      mutation createNote($body: String!) {
-        createNote(input: {noteableId: "1", body: $body}) {
-          note {
-            id
-          }
-        }
-      }
-    GRAPHQL
-  end
-
-  describe '#final_value' do
-    let(:monotonic_time_before) { 42 }
-    let(:monotonic_time_after) { 500 }
-    let(:monotonic_time_duration) { monotonic_time_after - monotonic_time_before }
-    let(:memo) { initial_value }
-
-    subject(:final_value) { analyzer.final_value(memo) }
-
-    before do
-      RequestStore.store[:graphql_logs] = nil
-
-      allow(GraphQL::Analysis).to receive(:analyze_query).and_return([4, 2, [[], []]])
-      allow(Gitlab::Metrics::System).to receive(:monotonic_time).and_return(monotonic_time_before, monotonic_time_after)
-      allow(Gitlab::GraphqlLogger).to receive(:info)
-    end
-
-    it 'inserts duration in seconds to memo and sets request store' do
-      expect { final_value }.to change { memo[:duration_s] }.to(monotonic_time_duration)
-                            .and change { RequestStore.store[:graphql_logs] }.to([{
-                              complexity: 4,
-                              depth: 2,
-                              operation_name: query.operation_name,
-                              used_deprecated_fields: [],
-                              used_fields: [],
-                              variables: { body: "[FILTERED]" }.to_s
-                            }])
-    end
-  end
-end
diff --git a/spec/lib/gitlab/graphql/tracers/logger_tracer_spec.rb b/spec/lib/gitlab/graphql/tracers/logger_tracer_spec.rb
index 5bc077a963ea6986bfe9aacc079ff3fad46e03a5..20792fb45541b11865c3a462d3b2de59121753dc 100644
--- a/spec/lib/gitlab/graphql/tracers/logger_tracer_spec.rb
+++ b/spec/lib/gitlab/graphql/tracers/logger_tracer_spec.rb
@@ -8,7 +8,7 @@
       use Gitlab::Graphql::Tracers::LoggerTracer
       use Gitlab::Graphql::Tracers::TimerTracer
 
-      query_analyzer Gitlab::Graphql::QueryAnalyzers::LoggerAnalyzer.new
+      query_analyzer Gitlab::Graphql::QueryAnalyzers::AST::LoggerAnalyzer
 
       query Graphql::FakeQueryType
     end
@@ -20,11 +20,11 @@
     end
   end
 
-  it "logs every query", :aggregate_failures do
+  it "logs every query", :aggregate_failures, :unlimited_max_formatted_output_length do
     variables = { name: "Ada Lovelace" }
     query_string = 'query fooOperation($name: String) { helloWorld(message: $name) }'
 
-    # Build an actual query so we don't have to hardocde the "fingerprint" calculations
+    # Build an actual query so we don't have to hardcode the "fingerprint" calculations
     query = GraphQL::Query.new(dummy_schema, query_string, variables: variables)
 
     expect(::Gitlab::GraphqlLogger).to receive(:info).with({
diff --git a/spec/requests/api/graphql/ci/runners_spec.rb b/spec/requests/api/graphql/ci/runners_spec.rb
index d3e946717240ef764a203d54dd1025a42ca6559e..db611200084e3924c8b3f7bdd72d5946be1c097d 100644
--- a/spec/requests/api/graphql/ci/runners_spec.rb
+++ b/spec/requests/api/graphql/ci/runners_spec.rb
@@ -123,3 +123,47 @@ def pagination_results_data(runners)
     end
   end
 end
+
+RSpec.describe 'Group.runners' do
+  include GraphqlHelpers
+
+  let_it_be(:group) { create(:group) }
+  let_it_be(:group_owner) { create_default(:user) }
+
+  before do
+    group.add_owner(group_owner)
+  end
+
+  describe 'edges' do
+    let_it_be(:runner) do
+      create(:ci_runner, :group, active: false, version: 'def', revision: '456',
+             description: 'Project runner', groups: [group], ip_address: '127.0.0.1')
+    end
+
+    let(:query) do
+      %(
+        query($path: ID!) {
+          group(fullPath: $path) {
+            runners {
+              edges {
+                webUrl
+                editUrl
+                node { #{all_graphql_fields_for('CiRunner')} }
+              }
+            }
+          }
+        }
+      )
+    end
+
+    it 'contains custom edge information' do
+      r = GitlabSchema.execute(query,
+                               context: { current_user: group_owner },
+                               variables: { path: group.full_path })
+
+      edges = graphql_dig_at(r.to_h, :data, :group, :runners, :edges)
+
+      expect(edges).to contain_exactly(a_graphql_entity_for(web_url: be_present, edit_url: be_present))
+    end
+  end
+end
diff --git a/spec/requests/api/graphql/gitlab_schema_spec.rb b/spec/requests/api/graphql/gitlab_schema_spec.rb
index e80f5e0e0ff53f65f68e38e9b7e908f89039945d..c1beadb6c45227cba03873f7f7b5d2fc5dcb2949 100644
--- a/spec/requests/api/graphql/gitlab_schema_spec.rb
+++ b/spec/requests/api/graphql/gitlab_schema_spec.rb
@@ -190,7 +190,7 @@
     let(:query) { File.read(Rails.root.join('spec/fixtures/api/graphql/introspection.graphql')) }
 
     it 'logs the query complexity and depth' do
-      expect_any_instance_of(Gitlab::Graphql::QueryAnalyzers::LoggerAnalyzer).to receive(:duration).and_return(7)
+      expect_any_instance_of(Gitlab::Graphql::QueryAnalyzers::AST::LoggerAnalyzer).to receive(:duration).and_return(7)
 
       expect(Gitlab::GraphqlLogger).to receive(:info).with(
         hash_including(
diff --git a/spec/requests/api/graphql/mutations/container_repository/destroy_tags_spec.rb b/spec/requests/api/graphql/mutations/container_repository/destroy_tags_spec.rb
index decb2e7bccc4e94776869ae2d2f6f15e49ad01fa..ef00f45ef1845a9717606523aca7f4412583f02f 100644
--- a/spec/requests/api/graphql/mutations/container_repository/destroy_tags_spec.rb
+++ b/spec/requests/api/graphql/mutations/container_repository/destroy_tags_spec.rb
@@ -91,7 +91,7 @@
       it 'returns too many tags error' do
         expect { subject }.not_to change { ::Packages::Event.count }
 
-        explanation = graphql_errors.dig(0, 'extensions', 'problems', 0, 'explanation')
+        explanation = graphql_errors.dig(0, 'message')
         expect(explanation).to eq(Mutations::ContainerRepositories::DestroyTags::TOO_MANY_TAGS_ERROR_MESSAGE)
       end
     end
diff --git a/spec/requests/api/graphql/mutations/design_management/delete_spec.rb b/spec/requests/api/graphql/mutations/design_management/delete_spec.rb
index 1f43f113e656e79b0f6c765aa00422c967ef6110..e2ab08b301b2a6a7b97b5038a96a9a86a3982316 100644
--- a/spec/requests/api/graphql/mutations/design_management/delete_spec.rb
+++ b/spec/requests/api/graphql/mutations/design_management/delete_spec.rb
@@ -47,7 +47,7 @@ def mutate!
   context 'the designs list is empty' do
     it_behaves_like 'a failed request' do
       let(:designs) { [] }
-      let(:the_error) { a_string_matching %r/was provided invalid value/ }
+      let(:the_error) { a_string_matching %r/no filenames/ }
     end
   end
 
diff --git a/spec/requests/api/graphql/mutations/metrics/dashboard/annotations/create_spec.rb b/spec/requests/api/graphql/mutations/metrics/dashboard/annotations/create_spec.rb
index 5bc3c68cf26b7c745a071937aac3309acf96cb05..9ef443af76a9acf86a00bcf21f9c128f6c2c1fb8 100644
--- a/spec/requests/api/graphql/mutations/metrics/dashboard/annotations/create_spec.rb
+++ b/spec/requests/api/graphql/mutations/metrics/dashboard/annotations/create_spec.rb
@@ -76,7 +76,6 @@ def mutation_response
       context 'when environment_id is missing' do
         let(:mutation) do
           variables = {
-            environment_id: nil,
             starting_at: starting_at,
             ending_at: ending_at,
             dashboard_path: dashboard_path,
@@ -147,7 +146,6 @@ def mutation_response
       context 'when cluster_id is missing' do
         let(:mutation) do
           variables = {
-            cluster_id: nil,
             starting_at: starting_at,
             ending_at: ending_at,
             dashboard_path: dashboard_path,
diff --git a/spec/requests/api/graphql/mutations/notes/reposition_image_diff_note_spec.rb b/spec/requests/api/graphql/mutations/notes/reposition_image_diff_note_spec.rb
index 0f7ccac3179d765fe90ce7d004e57fe91e671776..c4674155aa0b08c05297abe4f145ec5c03cfd658 100644
--- a/spec/requests/api/graphql/mutations/notes/reposition_image_diff_note_spec.rb
+++ b/spec/requests/api/graphql/mutations/notes/reposition_image_diff_note_spec.rb
@@ -68,15 +68,7 @@ def mutation_response
     let(:new_position) { { x: nil } }
 
     it_behaves_like 'a mutation that returns top-level errors' do
-      let(:match_errors) { include(/RepositionImageDiffNoteInput! was provided invalid value/) }
-    end
-
-    it 'contains an explanation for the error' do
-      post_graphql_mutation(mutation, current_user: current_user)
-
-      explanation = graphql_errors.first['extensions']['problems'].first['explanation']
-
-      expect(explanation).to eq('At least one property of `UpdateDiffImagePositionInput` must be set')
+      let(:match_errors) { include(/At least one property of `UpdateDiffImagePositionInput` must be set/) }
     end
   end
 end
diff --git a/spec/requests/api/graphql_spec.rb b/spec/requests/api/graphql_spec.rb
index 3bd59450d498e177e07509c28f5c41331ff61920..d94257c61eb726372c6c9e784f455d7ce31b1b06 100644
--- a/spec/requests/api/graphql_spec.rb
+++ b/spec/requests/api/graphql_spec.rb
@@ -67,10 +67,10 @@
 
     context 'when there is an error in the logger' do
       before do
-        logger_analyzer = GitlabSchema.query_analyzers.find do |qa|
-          qa.is_a? Gitlab::Graphql::QueryAnalyzers::LoggerAnalyzer
-        end
-        allow(logger_analyzer).to receive(:process_variables)
+        allow(GraphQL::Analysis::AST).to receive(:analyze_query)
+          .and_call_original
+        allow(GraphQL::Analysis::AST).to receive(:analyze_query)
+          .with(anything, Gitlab::Graphql::QueryAnalyzers::AST::LoggerAnalyzer::ALL_ANALYZERS, anything)
           .and_raise(StandardError.new("oh noes!"))
       end
 
diff --git a/spec/support/graphql/field_inspection.rb b/spec/support/graphql/field_inspection.rb
index e5fe37ec555fd101e12a44580b60893b80ace02c..8730f82b893dafed928220110ef3f21f800a9f33 100644
--- a/spec/support/graphql/field_inspection.rb
+++ b/spec/support/graphql/field_inspection.rb
@@ -20,7 +20,7 @@ def enum?
 
     def type
       @type ||= begin
-        field_type = @field.type.respond_to?(:to_graphql) ? @field.type.to_graphql : @field.type
+        field_type = @field.type
 
         # The type could be nested. For example `[GraphQL::Types::String]`:
         # - List
diff --git a/spec/support/graphql/field_selection.rb b/spec/support/graphql/field_selection.rb
index 00323c46d69ad891b374deaf5a4ebcdd96247510..432340cfdb57d45a3ab57c6721c94bfb732201f0 100644
--- a/spec/support/graphql/field_selection.rb
+++ b/spec/support/graphql/field_selection.rb
@@ -46,7 +46,7 @@ def serialize_field_selection(hash, level = 0)
 
     NO_SKIP = ->(_name, _field) { false }
 
-    def self.select_fields(type, skip = NO_SKIP, parent_types = Set.new, max_depth = 3)
+    def self.select_fields(type, skip = NO_SKIP, max_depth = 3)
       return new if max_depth <= 0 || !type.kind.fields?
 
       new(type.fields.flat_map do |name, field|
@@ -55,12 +55,8 @@ def self.select_fields(type, skip = NO_SKIP, parent_types = Set.new, max_depth =
         inspected = ::Graphql::FieldInspection.new(field)
         singular_field_type = inspected.type
 
-        # If field type is the same as parent type, then we're hitting into
-        # mutual dependency. Break it from infinite recursion
-        next [] if parent_types.include?(singular_field_type)
-
         if inspected.nested_fields?
-          subselection = select_fields(singular_field_type, skip, parent_types | [type], max_depth - 1)
+          subselection = select_fields(singular_field_type, skip, max_depth - 1)
           next [] if subselection.empty?
 
           [[name, subselection.to_h]]
diff --git a/spec/support/helpers/graphql_helpers.rb b/spec/support/helpers/graphql_helpers.rb
index 7aaf11498cf4cbfb46f701a28233ebec18742640..6cdd8a9446eaf374b068884129e1e52919c23e97 100644
--- a/spec/support/helpers/graphql_helpers.rb
+++ b/spec/support/helpers/graphql_helpers.rb
@@ -26,10 +26,44 @@ def self.deep_fieldnamerize(map)
     end
   end
 
+  # Some arguments use `as:` to expose a different name internally.
+  # Transform the args to use those names
+  def self.deep_transform_args(args, field)
+    args.to_h do |k, v|
+      argument = field.arguments[k.to_s.camelize(:lower)]
+      [argument.keyword, v.is_a?(Hash) ? deep_transform_args(v, argument.type) : v]
+    end
+  end
+
+  # Convert incoming args into the form usually passed in from the client,
+  # all strings, etc.
+  def self.as_graphql_argument_literals(args)
+    args.transform_values { |value| transform_arg_value(value) }
+  end
+
+  def self.transform_arg_value(value)
+    case value
+    when Hash
+      as_graphql_argument_literals(value)
+    when Array
+      value.map { |x| transform_arg_value(x) }
+    when Time, ActiveSupport::TimeWithZone
+      value.strftime("%F %T.%N %z")
+    when Date, GlobalID, Symbol
+      value.to_s
+    else
+      value
+    end
+  end
+
   # Run this resolver exactly as it would be called in the framework. This
   # includes all authorization hooks, all argument processing and all result
   # wrapping.
   # see: GraphqlHelpers#resolve_field
+  #
+  # TODO: this is too coupled to gem internals, making upgrades incredibly
+  #       painful, and bypasses much of the validation of the framework.
+  #       See https://gitlab.com/gitlab-org/gitlab/-/issues/363121
   def resolve(
     resolver_class, # [Class[<= BaseResolver]] The resolver at test.
     obj: nil, # [Any] The BaseObject#object for the resolver (available as `#object` in the resolver).
@@ -37,7 +71,8 @@ def resolve(
     ctx: {},  # [#to_h] The current context values.
     schema: GitlabSchema, # [GraphQL::Schema] Schema to use during execution.
     parent: :not_given, # A GraphQL query node to be passed as the `:parent` extra.
-    lookahead: :not_given # A GraphQL lookahead object to be passed as the `:lookahead` extra.
+    lookahead: :not_given, # A GraphQL lookahead object to be passed as the `:lookahead` extra.
+    arg_style: :internal # Args are in internal format, rather than client/external format
   )
     # All resolution goes through fields, so we need to create one here that
     # uses our resolver. Thankfully, apart from the field name, resolvers
@@ -49,7 +84,6 @@ def resolve(
     field = ::Types::BaseField.new(**field_options)
 
     # All mutations accept a single `:input` argument. Wrap arguments here.
-    # See the unwrapping below in GraphqlHelpers#resolve_field
     args = { input: args } if resolver_class <= ::Mutations::BaseMutation && !args.key?(:input)
 
     resolve_field(field, obj,
@@ -57,7 +91,8 @@ def resolve(
                   ctx: ctx,
                   schema: schema,
                   object_type: resolver_parent,
-                  extras: { parent: parent, lookahead: lookahead })
+                  extras: { parent: parent, lookahead: lookahead },
+                  arg_style: arg_style)
   end
 
   # Resolve the value of a field on an object.
@@ -85,21 +120,22 @@ def resolve(
   # NB: Arguments are passed from the client's perspective. If there is an argument
   # `foo` aliased as `bar`, then we would pass `args: { bar: the_value }`, and
   # types are checked before resolution.
+  # rubocop:disable Metrics/ParameterLists
   def resolve_field(
-    field,                       # An instance of `BaseField`, or the name of a field on the current described_class
-    object,                      # The current object of the `BaseObject` this field 'belongs' to
-    args:   {},                  # Field arguments (keys will be fieldnamerized)
-    ctx:    {},                  # Context values (important ones are :current_user)
-    extras: {},                  # Stub values for field extras (parent and lookahead)
-    current_user: :not_given,    # The current user (specified explicitly, overrides ctx[:current_user])
-    schema: GitlabSchema,        # A specific schema instance
-    object_type: described_class # The `BaseObject` type this field belongs to
+    field,                        # An instance of `BaseField`, or the name of a field on the current described_class
+    object,                       # The current object of the `BaseObject` this field 'belongs' to
+    args:   {},                   # Field arguments (keys will be fieldnamerized)
+    ctx:    {},                   # Context values (important ones are :current_user)
+    extras: {},                   # Stub values for field extras (parent and lookahead)
+    current_user: :not_given,     # The current user (specified explicitly, overrides ctx[:current_user])
+    schema: GitlabSchema,         # A specific schema instance
+    object_type: described_class, # The `BaseObject` type this field belongs to
+    arg_style: :internal          # Args are in internal format, rather than client/external format
   )
     field = to_base_field(field, object_type)
     ctx[:current_user] = current_user unless current_user == :not_given
     query = GraphQL::Query.new(schema, context: ctx.to_h)
     extras[:lookahead] = negative_lookahead if extras[:lookahead] == :not_given && field.extras.include?(:lookahead)
-
     query_ctx = query.context
 
     mock_extras(query_ctx, **extras)
@@ -107,29 +143,61 @@ def resolve_field(
     parent = object_type.authorized_new(object, query_ctx)
     raise UnauthorizedObject unless parent
 
-    # TODO: This will need to change when we move to the interpreter:
-    # At that point, arguments will be a plain ruby hash rather than
-    # an Arguments object
-    # see: https://gitlab.com/gitlab-org/gitlab/-/merge_requests/27536
-    #      https://gitlab.com/gitlab-org/gitlab/-/issues/210556
-    arguments = field.to_graphql.arguments_class.new(
-      GraphqlHelpers.deep_fieldnamerize(args),
-      context: query_ctx,
-      defaults_used: []
-    )
+    # mutations already working with :internal_prepared
+    arg_style = :internal_prepared if args[:input] && arg_style == :internal
 
     # we enable the request store so we can track gitaly calls.
     ::Gitlab::WithRequestStore.with_request_store do
-      # TODO: This will need to change when we move to the interpreter - at that
-      # point we will call `field#resolve`
-
-      # Unwrap the arguments to mutations. This pairs with the wrapping in GraphqlHelpers#resolve
-      # If arguments are not wrapped first, then arguments processing will raise.
-      # If arguments are not unwrapped here, then the resolve method of the mutation will raise argument errors.
-      arguments = arguments.to_kwargs[:input] if field.resolver && field.resolver <= ::Mutations::BaseMutation
+      prepared_args = case arg_style
+                      when :internal_prepared
+                        args_internal_prepared(field, args: args, query_ctx: query_ctx, parent: parent, extras: extras, query: query)
+                      else
+                        args_internal(field, args: args, query_ctx: query_ctx, parent: parent, extras: extras, query: query)
+                      end
+
+      if prepared_args.class <= Gitlab::Graphql::Errors::BaseError
+        prepared_args
+      else
+        field.resolve(parent, prepared_args, query_ctx)
+      end
+    end
+  end
+  # rubocop:enable Metrics/ParameterLists
 
-      field.resolve_field(parent, arguments, query_ctx)
+  # Pros:
+  #   - Most arguments we use in specs, which are already in an "internal" state, work
+  #
+  # Cons:
+  #   - the `prepare` method of a type is not called.  Whether as a proc or as a method
+  #     on the type, it's not called. For example `:cluster_id` in ee/app/graphql/resolvers/vulnerabilities_resolver.rb,
+  #     or `prepare` in app/graphql/types/range_input_type.rb, used by Types::TimeframeInputType
+  def args_internal(field, args:, query_ctx:, parent:, extras:, query:)
+    arguments = GraphqlHelpers.deep_transform_args(args, field)
+    arguments.merge!(extras.reject {|k, v| v == :not_given})
+  end
+
+  # Pros:
+  #   - Allows the use of ruby types, without having to pass in strings
+  #   - All args are converted into strings just like if it was called from a client,
+  #     so stronger arg verification
+  #
+  # Cons:
+  #   - Some values, such as enums, would need to be changed in the specs to use the
+  #     external values, because there is no easy way to handle them.
+  #
+  # take internal style args, and force them into client style args
+  def args_internal_prepared(field, args:, query_ctx:, parent:, extras:, query:)
+    arguments = GraphqlHelpers.as_graphql_argument_literals(args)
+    arguments.merge!(extras.reject {|k, v| v == :not_given})
+
+    # Use public API to properly prepare the args for use by the resolver.
+    # It uses `coerce_arguments` under the covers
+    prepared_args = nil
+    query.arguments_cache.dataload_for(GraphqlHelpers.deep_fieldnamerize(arguments), field, parent) do |kwarg_arguments|
+      prepared_args = kwarg_arguments
     end
+
+    prepared_args.respond_to?(:keyword_arguments) ? prepared_args.keyword_arguments : prepared_args
   end
 
   def mock_extras(context, parent: :not_given, lookahead: :not_given)
@@ -148,7 +216,7 @@ def fresh_object_type(name = 'Object')
 
   def resolver_instance(resolver_class, obj: nil, ctx: {}, field: nil, schema: GitlabSchema, subscription_update: false)
     if ctx.is_a?(Hash)
-      q = double('Query', schema: schema, subscription_update?: subscription_update)
+      q = double('Query', schema: schema, subscription_update?: subscription_update, warden: GraphQL::Schema::Warden::PassThruWarden)
       ctx = GraphQL::Query::Context.new(query: q, object: obj, values: ctx)
     end
 
@@ -358,7 +426,7 @@ def query_graphql_path(segments, fields = nil)
   end
 
   def query_double(schema:)
-    double('query', schema: schema)
+    double('query', schema: schema, warden: GraphQL::Schema::Warden::PassThruWarden)
   end
 
   def wrap_fields(fields)
@@ -380,7 +448,7 @@ def wrap_fields(fields)
     FIELDS
   end
 
-  def all_graphql_fields_for(class_name, parent_types = Set.new, max_depth: 3, excluded: [])
+  def all_graphql_fields_for(class_name, max_depth: 3, excluded: [])
     # pulling _all_ fields can generate a _huge_ query (like complexity 180,000),
     # and significantly increase spec runtime. so limit the depth by default
     return if max_depth <= 0
@@ -397,7 +465,7 @@ def all_graphql_fields_for(class_name, parent_types = Set.new, max_depth: 3, exc
     # We can't guess arguments, so skip fields that require them
     skip = ->(name, field) { excluded.include?(name) || required_arguments?(field) }
 
-    ::Graphql::FieldSelection.select_fields(type, skip, parent_types, max_depth)
+    ::Graphql::FieldSelection.select_fields(type, skip, max_depth)
   end
 
   def with_signature(variables, query)
@@ -569,8 +637,11 @@ def expect_graphql_errors_to_be_empty
 
   # Helps migrate to the new GraphQL interpreter,
   # https://gitlab.com/gitlab-org/gitlab/-/issues/210556
-  def expect_graphql_error_to_be_created(error_class, match_message = nil)
-    expect { yield }.to raise_error(error_class, match_message)
+  def expect_graphql_error_to_be_created(error_class, match_message = '')
+    resolved = yield
+
+    expect(resolved).to be_instance_of(error_class)
+    expect(resolved.message).to match(match_message)
   end
 
   def flattened_errors
@@ -644,7 +715,7 @@ def allow_unlimited_graphql_depth
   end
 
   def allow_high_graphql_recursion
-    allow_any_instance_of(Gitlab::Graphql::QueryAnalyzers::RecursionAnalyzer).to receive(:recursion_threshold).and_return 1000
+    allow_any_instance_of(Gitlab::Graphql::QueryAnalyzers::AST::RecursionAnalyzer).to receive(:recursion_threshold).and_return 1000
   end
 
   def allow_high_graphql_transaction_threshold
@@ -717,7 +788,6 @@ def execute_query(query_type = Types::QueryType, schema: empty_schema, graphql:
 
   def empty_schema
     Class.new(GraphQL::Schema) do
-      use GraphQL::Pagination::Connections
       use Gitlab::Graphql::Pagination::Connections
       use BatchLoader::GraphQL
 
@@ -817,7 +887,3 @@ def field_by_name(name, object_type)
     object_type.fields[name] || (raise ArgumentError, "Unknown field #{name} for #{described_class.graphql_name}")
   end
 end
-
-# This warms our schema, doing this as part of loading the helpers to avoid
-# duplicate loading error when Rails tries autoload the types.
-GitlabSchema.graphql_definition