From 76171c5f0e68a8ba18ccd747ea11e1632de66de8 Mon Sep 17 00:00:00 2001
From: Brett Walker <bwalker@gitlab.com>
Date: Tue, 23 Nov 2021 10:37:35 -0600
Subject: [PATCH 01/14] Move to the new GraphQL interpreter

- Update to graphql 1.13.12
- Create the new AST LoggerAnalyzer ported from the original LoggerAnalyzer
- Create the new AST RecursionAnalyzer ported from the original RecursionAnalyzer
- Override unauthorized_object(unauthorized_error)
- Fix arg handlling in GraphQL::Helpers
- Now some exceptions are being caught much earlier,
  breaking many unit test specs that relied on checking
  for exceptions
- Must override == in the class itself
- GraphQL-Ruby's types used to override def ==(other),
  but it doesn't anymore when using the interpreter
- Procs are no longer supported
- GraphQL::Pagination::Connections is now a default and
  is no longer needed
- Check for object in FindClosest
- Casues a GraphQL::Schema::DuplicateNamesError
- Add new expect_graphql_error_to_be_created
- Adjust how args are built for testing
- Removal of to_graphql
- Fix signature of get_type
- Override new complexity calculation to use our own
- When using `resolve` in GraphqlHelpers, the arguments
must be passed in a certain way. For this transition, we can
indicate how we want the arguments handled.
- BaseInputObject must return super from `prepare`
This has the correct effect of the entire input object being
passed through to the resolver in `args`.  Inside there
you need to call `to_h` to extract the ruby arguments.
- Remove prepare from NegatedBoardIssueInputType
- Return nil if TimeType is nil
Let higher level argument checks do their job.
Fixes spec/requests/api/graphql/mutations/releases/update_spec.rb
- DEBUG_GRAPHQL=1 now ignores graphql tracers
and sets the timeout to 20 mins, to facilitate
debugging
- Remove use of metadata[:type_class]
---
 Gemfile                                       |   2 +-
 Gemfile.lock                                  |   4 +-
 app/graphql/gitlab_schema.rb                  |  45 +++---
 app/graphql/mutations/base_mutation.rb        |  18 ++-
 app/graphql/types/base_field.rb               |  24 +++
 app/graphql/types/ci/detailed_status_type.rb  |   2 +-
 app/graphql/types/ci/runner_web_url_edge.rb   |   2 +-
 app/graphql/types/ci/status_action_type.rb    |   2 +-
 app/graphql/types/concerns/find_closest.rb    |   5 +-
 app/graphql/types/global_id_type.rb           |   3 +-
 .../interacts_with_merge_request.rb           |   2 +-
 app/graphql/types/query_complexity_type.rb    |   4 +-
 app/graphql/types/time_type.rb                |   2 +
 ee/app/presenters/iteration_presenter.rb      |  11 +-
 .../compliance_violation_resolver_spec.rb     |   2 +-
 .../escalation_policies_resolver_spec.rb      |   2 +-
 .../oncall_rotations_resolver_spec.rb         |   2 +-
 .../resolvers/iterations_resolver_spec.rb     |  23 ++-
 .../vulnerabilities_resolver_spec.rb          |   2 +-
 .../oncall_rotation/create_spec.rb            |   8 +-
 lib/gitlab/graphql/generic_tracing.rb         |   8 +
 lib/gitlab/graphql/present/field_extension.rb |   1 +
 .../query_analyzers/ast/logger_analyzer.rb    |  81 ++++++++++
 .../query_analyzers/ast/recursion_analyzer.rb |  78 +++++++++
 .../query_analyzers/logger_analyzer.rb        |  84 ----------
 .../query_analyzers/recursion_analyzer.rb     |  62 --------
 spec/controllers/graphql_controller_spec.rb   |   8 +-
 spec/graphql/gitlab_schema_spec.rb            |  10 +-
 .../boards/issues/issue_move_list_spec.rb     |   2 +-
 .../timeline_events_resolver_spec.rb          |   2 +-
 .../subscriptions/issuable_updated_spec.rb    |   3 +-
 spec/graphql/types/base_edge_spec.rb          |   1 -
 spec/graphql/types/base_object_spec.rb        |   1 -
 .../types/ci/detailed_status_type_spec.rb     |   4 +-
 .../types/ci/status_action_type_spec.rb       |   8 +-
 spec/graphql/types/time_type_spec.rb          |   5 +-
 .../lib/gitlab/graphql/markdown_field_spec.rb |   7 -
 .../graphql/negatable_arguments_spec.rb       |   4 +-
 .../graphql/present/field_extension_spec.rb   |  17 --
 .../ast/logger_analyzer_spec.rb               |  44 +++++
 .../ast/recursion_analyzer_spec.rb            |  72 +++++++++
 .../query_analyzers/logger_analyzer_spec.rb   |  49 ------
 .../graphql/tracers/logger_tracer_spec.rb     |  27 ++--
 .../api/graphql/gitlab_schema_spec.rb         |   2 +-
 .../container_repository/destroy_tags_spec.rb |   2 +-
 .../design_management/delete_spec.rb          |   2 +-
 .../dashboard/annotations/create_spec.rb      |   2 -
 .../notes/reposition_image_diff_note_spec.rb  |  10 +-
 spec/requests/api/graphql_spec.rb             |  11 +-
 spec/support/graphql/field_inspection.rb      |   2 +-
 spec/support/graphql/field_selection.rb       |   8 +-
 spec/support/helpers/graphql_helpers.rb       | 150 +++++++++++++-----
 52 files changed, 541 insertions(+), 391 deletions(-)
 create mode 100644 lib/gitlab/graphql/query_analyzers/ast/logger_analyzer.rb
 create mode 100644 lib/gitlab/graphql/query_analyzers/ast/recursion_analyzer.rb
 delete mode 100644 lib/gitlab/graphql/query_analyzers/logger_analyzer.rb
 delete mode 100644 lib/gitlab/graphql/query_analyzers/recursion_analyzer.rb
 create mode 100644 spec/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer_spec.rb
 create mode 100644 spec/lib/gitlab/graphql/query_analyzers/ast/recursion_analyzer_spec.rb
 delete mode 100644 spec/lib/gitlab/graphql/query_analyzers/logger_analyzer_spec.rb

diff --git a/Gemfile b/Gemfile
index 08bcb0aca0389d..711a316d1f1b64 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 527ac45b1010b3..19cda99e4dca90 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 9b23aa60eab87d..eb5f6d4f24004c 100644
--- a/app/graphql/gitlab_schema.rb
+++ b/app/graphql/gitlab_schema.rb
@@ -10,21 +10,28 @@ class GitlabSchema < GraphQL::Schema
   DEFAULT_MAX_DEPTH = 15
   AUTHENTICATED_MAX_DEPTH = 20
 
-  # Tracers (order is important)
-  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
-  use Gitlab::Graphql::Tracers::TimerTracer
+  if ENV['DEBUG_GRAPHQL']
+    use Gitlab::Graphql::Timeout, max_seconds: 1200
+  else
+    # Tracers (order is important)
+    use Gitlab::Graphql::Tracers::ApplicationContextTracer
+    use Gitlab::Graphql::Tracers::MetricsTracer
+    use Gitlab::Graphql::Tracers::LoggerTracer
+
+    # 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 Gitlab::Graphql::Timeout, max_seconds: Gitlab.config.gitlab.graphql_timeout
+  end
 
   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 +56,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 +84,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 +174,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 d57a097a9e2ed6..5f98b222099ce7 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 83c53e568e91c8..6aee9a5c052462 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 e3413551a3f63d..3fab040cc0b1f1 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 035d75c22c67f4..ae12979871ee75 100644
--- a/app/graphql/types/ci/runner_web_url_edge.rb
+++ b/app/graphql/types/ci/runner_web_url_edge.rb
@@ -30,7 +30,7 @@ def web_url(parent:)
       private
 
       def runner_url(parent:, url_type: :default)
-        owner = closest_parent([::Types::ProjectType, ::Types::GroupType], parent)
+        owner = closest_parent([::Project, ::Group], parent)
 
         # Only ::Group is supported at the moment, future iterations will include ::Project.
         # See https://gitlab.com/gitlab-org/gitlab/-/issues/16338
diff --git a/app/graphql/types/ci/status_action_type.rb b/app/graphql/types/ci/status_action_type.rb
index 26ca3c1438aced..fa7ef92dbb586c 100644
--- a/app/graphql/types/ci/status_action_type.rb
+++ b/app/graphql/types/ci/status_action_type.rb
@@ -21,7 +21,7 @@ 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.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
index 3064db19ea0e66..3fb65a7d87780c 100644
--- a/app/graphql/types/concerns/find_closest.rb
+++ b/app/graphql/types/concerns/find_closest.rb
@@ -1,12 +1,11 @@
 # 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
+      if types.any? {|type| parent.instance_of? type}
+        return parent
       else
         parent = parent.try(:parent)
       end
diff --git a/app/graphql/types/global_id_type.rb b/app/graphql/types/global_id_type.rb
index 6a924c13a3c6cc..145a5a22460886 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 15621ef1472f72..e71f46f75cffcd 100644
--- a/app/graphql/types/merge_requests/interacts_with_merge_request.rb
+++ b/app/graphql/types/merge_requests/interacts_with_merge_request.rb
@@ -16,7 +16,7 @@ module InteractsWithMergeRequest
       end
 
       def merge_request_interaction(parent:, id: nil)
-        merge_request = closest_parent([::Types::MergeRequestType], parent)
+        merge_request = closest_parent([::MergeRequest, ::MergeRequestPresenter], parent)
 
         return unless merge_request
 
diff --git a/app/graphql/types/query_complexity_type.rb b/app/graphql/types/query_complexity_type.rb
index 13b618cf5cea8f..ddcf448c64ad98 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 2db14953308c56..40b097231de353 100644
--- a/app/graphql/types/time_type.rb
+++ b/app/graphql/types/time_type.rb
@@ -12,6 +12,8 @@ class TimeType < BaseScalar
     DESC
 
     def self.coerce_input(value, ctx)
+      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 63871c7cc432bf..92b47c9479a600 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 45b7971580e6b4..179856ccd976ae 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 5ae7d4dfd35e5b..ea01ae9c2aab76 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 e83d22b08cfe95..6e2253b8aeaa4f 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 172e38785ddaac..ad205ee7c9cd2a 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 b540d1af958bba..fde7bc5aa33bde 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 08d2f9994f6321..27a80177b7b3de 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 936b22d5afa89a..d3de9c714f4d8a 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 050a3a276eadf1..bc6d0c6fd35e61 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 00000000000000..8220523ff65f83
--- /dev/null
+++ b/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer.rb
@@ -0,0 +1,81 @@
+# 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
+
+            variables = process_variables(query.provided_variables)
+            @results = default_initial_values(query).merge({
+              operation_name: query.operation_name,
+              query_string: query.query_string,
+              time_started: Gitlab::Metrics::System.monotonic_time,
+              variables: variables
+            })
+          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]).round(1)
+            results[:used_fields] = field_usages[:used_fields]
+            results[:used_deprecated_fields] = field_usages[:used_deprecated_fields]
+
+            RequestStore.store[:graphql_logs] ||= []
+            RequestStore.store[:graphql_logs] << 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 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,
+              query_string: nil,
+              query: query,
+              variables: nil,
+              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 00000000000000..4e90e4c912f3e2
--- /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 207324e73bd892..00000000000000
--- 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 79a7104a2fff8a..00000000000000
--- 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 0818dce776dfdd..ae6fddd60f12f7 100644
--- a/spec/controllers/graphql_controller_spec.rb
+++ b/spec/controllers/graphql_controller_spec.rb
@@ -363,7 +363,9 @@
           depth: 2,
           used_deprecated_fields: [],
           used_fields: ['Project.id', 'Project.name', 'Query.project'],
-          variables: '{}'
+          variables: '{}',
+          query_string: "query getProject_1{ project(fullPath: \"foo\"){\n  id\nname\n}\n }",
+          duration_s: 0.0
         },
         {
           operation_name: 'getProject_2',
@@ -371,7 +373,9 @@
           depth: 2,
           used_deprecated_fields: [],
           used_fields: ['Project.id', 'Query.project'],
-          variables: '{}'
+          variables: '{}',
+          query_string: "query getProject_2{ project(fullPath: \"bar\"){\n  id\n}\n }",
+          duration_s: 0.0
         }
       ]
     end
diff --git a/spec/graphql/gitlab_schema_spec.rb b/spec/graphql/gitlab_schema_spec.rb
index 02c686af6888ff..0fbfca2f5fd0ce 100644
--- a/spec/graphql/gitlab_schema_spec.rb
+++ b/spec/graphql/gitlab_schema_spec.rb
@@ -8,11 +8,11 @@
   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 +219,8 @@ def initialize(id)
             badField
             veryBadField
             alsoNotAGoodField
+            yetAnotherBadField
+            andYetAnother
           }
         }
       GQL
@@ -312,4 +314,8 @@ def initialize(id)
   def field_instrumenters
     described_class.instrumenters[:field] + described_class.instrumenters[:field_after_built_ins]
   end
+
+  def tracers
+    described_class.tracers
+  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 b9d19b68001ed2..10aed8a1f009d8 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/resolvers/incident_management/timeline_events_resolver_spec.rb b/spec/graphql/resolvers/incident_management/timeline_events_resolver_spec.rb
index 6604141abfe919..bd41af533cee1c 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 0b8fcf67513014..bc640e9e3c4478 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 3afb4202173419..b02ccbaffef875 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 45dc885ecba799..3c42c708187b7e 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 5ed79b73a47772..0bcb58202ad965 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 ab7dee3dd11412..1ea31416ef5e7a 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 3b0d257e1d7f6a..367a2371694457 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/lib/gitlab/graphql/markdown_field_spec.rb b/spec/lib/gitlab/graphql/markdown_field_spec.rb
index a73eba1e9db2c5..4d38941a61801e 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 71ef75836c0e0f..04ee1c1b820727 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 5f0f444e0bb655..49992d7b71f4b2 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 00000000000000..eba6e96c649470
--- /dev/null
+++ b/spec/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer_spec.rb
@@ -0,0 +1,44 @@
+# 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
+      result = GraphQL::Analysis::AST.analyze_query(query, [described_class], multiplex_analyzers: [])
+
+      expect(result.first[:duration_s]).to eq monotonic_time_duration
+      expect(result.first[:variables]).to eq '{:body=>"[FILTERED]"}'
+      expect(result.first[:depth]).to eq 3
+      expect(result.first[:complexity]).to eq 3
+      expect(result.first[:used_fields]).to eq ['Note.id', 'CreateNotePayload.note', 'Mutation.createNote']
+      expect(RequestStore.store[:graphql_logs]).to eq result
+    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 00000000000000..997fb129f424c1
--- /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 dee8f9e3c64a65..00000000000000
--- 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 5bc077a963ea69..0b4067bdc64fdb 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
@@ -24,26 +24,29 @@
     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({
+      trace_type: "execute_query",
+      query_fingerprint: query.fingerprint,
+      duration_s: be > 0,
+      operation_name: 'fooOperation',
+      operation_fingerprint: query.operation_fingerprint,
+      is_mutation: false,
+      variables: variables.to_s,
+      query_string: query_string,
       "correlation_id" => anything,
       "meta.caller_id" => "caller_a",
       "meta.feature_category" => "feature_a",
+      "query_analysis.query_string" => query_string,
+      "query_analysis.variables" => variables.to_s,
       "query_analysis.duration_s" => kind_of(Numeric),
-      "query_analysis.complexity" => 1,
+      "query_analysis.operation_name" => 'fooOperation',
       "query_analysis.depth" => 1,
-      "query_analysis.used_deprecated_fields" => [],
+      "query_analysis.complexity" => 1,
       "query_analysis.used_fields" => ["FakeQuery.helloWorld"],
-      duration_s: be > 0,
-      is_mutation: false,
-      operation_fingerprint: query.operation_fingerprint,
-      operation_name: 'fooOperation',
-      query_fingerprint: query.fingerprint,
-      query_string: query_string,
-      trace_type: "execute_query",
-      variables: variables.to_s
+      "query_analysis.used_deprecated_fields" => []
     })
 
     dummy_schema.execute(query_string, variables: variables)
diff --git a/spec/requests/api/graphql/gitlab_schema_spec.rb b/spec/requests/api/graphql/gitlab_schema_spec.rb
index e80f5e0e0ff53f..c1beadb6c45227 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 decb2e7bccc4e9..ef00f45ef1845a 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 1f43f113e656e7..e2ab08b301b2a6 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 5bc3c68cf26b7c..9ef443af76a9ac 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 0f7ccac3179d76..c4674155aa0b08 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 3bd59450d498e1..727220da53bbab 100644
--- a/spec/requests/api/graphql_spec.rb
+++ b/spec/requests/api/graphql_spec.rb
@@ -24,6 +24,9 @@
           "query_analysis.complexity" => 1,
           "query_analysis.used_fields" => ['Query.echo'],
           "query_analysis.used_deprecated_fields" => [],
+          "query_analysis.variables" => variables.to_s,
+          "query_analysis.operation_name" => nil,
+          "query_analysis.query_string" => query,
           # query_fingerprint starts with operation name
           query_fingerprint: %r{^anonymous\/},
           duration_s: kind_of(Numeric),
@@ -67,10 +70,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 e5fe37ec555fd1..8730f82b893daf 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 00323c46d69ad8..432340cfdb57d4 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 7aaf11498cf4cb..6cdd8a9446eaf3 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
-- 
GitLab


From 3b70d694977e6c5336ec4cd2690a9d85070063c7 Mon Sep 17 00:00:00 2001
From: Alex Kalderimis <akalderimis@gitlab.com>
Date: Tue, 24 May 2022 17:54:24 -0400
Subject: [PATCH 02/14] Remove FindClosest module

---
 app/graphql/types/concerns/find_closest.rb | 14 --------------
 1 file changed, 14 deletions(-)
 delete mode 100644 app/graphql/types/concerns/find_closest.rb

diff --git a/app/graphql/types/concerns/find_closest.rb b/app/graphql/types/concerns/find_closest.rb
deleted file mode 100644
index 3fb65a7d87780c..00000000000000
--- a/app/graphql/types/concerns/find_closest.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module FindClosest
-  def closest_parent(types, parent)
-    while parent
-
-      if types.any? {|type| parent.instance_of? type}
-        return parent
-      else
-        parent = parent.try(:parent)
-      end
-    end
-  end
-end
-- 
GitLab


From 3eb44f670862bcc0853e5cc1a7072f8e168bae19 Mon Sep 17 00:00:00 2001
From: Alex Kalderimis <akalderimis@gitlab.com>
Date: Tue, 24 May 2022 20:03:00 -0400
Subject: [PATCH 03/14] Add spec for Group.runners

---
 spec/requests/api/graphql/ci/runners_spec.rb | 44 ++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/spec/requests/api/graphql/ci/runners_spec.rb b/spec/requests/api/graphql/ci/runners_spec.rb
index d3e946717240ef..db611200084e39 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
-- 
GitLab


From 82fab95ac96189dc67f7e8486d16611f31d6fd27 Mon Sep 17 00:00:00 2001
From: Alex Kalderimis <akalderimis@gitlab.com>
Date: Tue, 24 May 2022 20:10:12 -0400
Subject: [PATCH 04/14] Remove uses of FindClosest

---
 app/graphql/types/ci/runner_web_url_edge.rb            | 10 +++-------
 .../merge_requests/interacts_with_merge_request.rb     |  8 ++------
 2 files changed, 5 insertions(+), 13 deletions(-)

diff --git a/app/graphql/types/ci/runner_web_url_edge.rb b/app/graphql/types/ci/runner_web_url_edge.rb
index ae12979871ee75..8b5bb9d7ccfa31 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]
@@ -30,15 +28,13 @@ def web_url(parent:)
       private
 
       def runner_url(parent:, url_type: :default)
-        owner = closest_parent([::Project, ::Group], parent)
-
         # Only ::Group is supported at the moment, future iterations will include ::Project.
         # See https://gitlab.com/gitlab-org/gitlab/-/issues/16338
-        case owner
+        case parent
         when ::Group
-          return Gitlab::Routing.url_helpers.edit_group_runner_url(owner, @runner) if url_type == :edit_url
+          return Gitlab::Routing.url_helpers.edit_group_runner_url(parent, @runner) if url_type == :edit_url
 
-          Gitlab::Routing.url_helpers.group_runner_url(owner, @runner)
+          Gitlab::Routing.url_helpers.group_runner_url(parent, @runner)
         end
       end
     end
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 e71f46f75cffcd..3d91625d16c588 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([::MergeRequest, ::MergeRequestPresenter], parent)
-
-        return unless merge_request
+        return unless parent.is_a?(MergeRequest)
 
-        Users::MergeRequestInteraction.new(user: object, merge_request: merge_request)
+        Users::MergeRequestInteraction.new(user: object, merge_request: parent)
       end
     end
   end
-- 
GitLab


From 06e516e8cb0c90b926bc7774741a77c0a925ae93 Mon Sep 17 00:00:00 2001
From: Alex Kalderimis <akalderimis@gitlab.com>
Date: Tue, 24 May 2022 20:25:43 -0400
Subject: [PATCH 05/14] Remove dead code

---
 .../types/merge_requests/interacts_with_merge_request.rb        | 2 --
 1 file changed, 2 deletions(-)

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 3d91625d16c588..ceeeb438f5f3e2 100644
--- a/app/graphql/types/merge_requests/interacts_with_merge_request.rb
+++ b/app/graphql/types/merge_requests/interacts_with_merge_request.rb
@@ -14,8 +14,6 @@ module InteractsWithMergeRequest
       end
 
       def merge_request_interaction(parent:, id: nil)
-        return unless parent.is_a?(MergeRequest)
-
         Users::MergeRequestInteraction.new(user: object, merge_request: parent)
       end
     end
-- 
GitLab


From 286ccd66b3eeb2f1ca07de42558608fddf47c784 Mon Sep 17 00:00:00 2001
From: Alex Kalderimis <akalderimis@gitlab.com>
Date: Tue, 24 May 2022 21:33:18 -0400
Subject: [PATCH 06/14] Handle parenting in connections

---
 app/graphql/types/ci/runner_web_url_edge.rb         | 13 +++++++------
 .../merge_requests/interacts_with_merge_request.rb  |  2 ++
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/app/graphql/types/ci/runner_web_url_edge.rb b/app/graphql/types/ci/runner_web_url_edge.rb
index 8b5bb9d7ccfa31..7dfcd1f3510841 100644
--- a/app/graphql/types/ci/runner_web_url_edge.rb
+++ b/app/graphql/types/ci/runner_web_url_edge.rb
@@ -17,24 +17,25 @@ 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)
+      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 parent
+        case owner
         when ::Group
-          return Gitlab::Routing.url_helpers.edit_group_runner_url(parent, @runner) if url_type == :edit_url
+          return Gitlab::Routing.url_helpers.edit_group_runner_url(owner, @runner) if url_type == :edit_url
 
-          Gitlab::Routing.url_helpers.group_runner_url(parent, @runner)
+          Gitlab::Routing.url_helpers.group_runner_url(owner, @runner)
         end
       end
     end
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 ceeeb438f5f3e2..bef2d39dc5c71a 100644
--- a/app/graphql/types/merge_requests/interacts_with_merge_request.rb
+++ b/app/graphql/types/merge_requests/interacts_with_merge_request.rb
@@ -14,6 +14,8 @@ module InteractsWithMergeRequest
       end
 
       def merge_request_interaction(parent:, id: nil)
+        # 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
-- 
GitLab


From 65ec8801dcd6b46de51359c912384a890bfb25f9 Mon Sep 17 00:00:00 2001
From: Brett Walker <bwalker@gitlab.com>
Date: Fri, 27 May 2022 08:52:40 -0500
Subject: [PATCH 07/14] Remove duplicate fields from logger

---
 lib/gitlab/graphql/tracers/logger_tracer.rb            | 6 +-----
 spec/graphql/types/work_items/widget_interface_spec.rb | 5 ++---
 spec/lib/gitlab/graphql/tracers/logger_tracer_spec.rb  | 4 ----
 spec/requests/api/graphql_spec.rb                      | 6 +-----
 4 files changed, 4 insertions(+), 17 deletions(-)

diff --git a/lib/gitlab/graphql/tracers/logger_tracer.rb b/lib/gitlab/graphql/tracers/logger_tracer.rb
index 3302b2bae3f77c..32b898f94c38ac 100644
--- a/lib/gitlab/graphql/tracers/logger_tracer.rb
+++ b/lib/gitlab/graphql/tracers/logger_tracer.rb
@@ -32,12 +32,8 @@ def log_execute_query(query: nil, duration_s: 0, exception: nil)
           info = {
             trace_type: 'execute_query',
             query_fingerprint: query.fingerprint,
-            duration_s: duration_s,
-            operation_name: query.operation_name,
             operation_fingerprint: query.operation_fingerprint,
-            is_mutation: query.mutation?,
-            variables: clean_variables(query.provided_variables),
-            query_string: query.query_string
+            is_mutation: query.mutation?
           }
 
           Gitlab::ExceptionLogFormatter.format!(exception, info)
diff --git a/spec/graphql/types/work_items/widget_interface_spec.rb b/spec/graphql/types/work_items/widget_interface_spec.rb
index 63d7782df28f98..6cb9ff65a4ff65 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/tracers/logger_tracer_spec.rb b/spec/lib/gitlab/graphql/tracers/logger_tracer_spec.rb
index 0b4067bdc64fdb..f7437524dc4a22 100644
--- a/spec/lib/gitlab/graphql/tracers/logger_tracer_spec.rb
+++ b/spec/lib/gitlab/graphql/tracers/logger_tracer_spec.rb
@@ -30,12 +30,8 @@
     expect(::Gitlab::GraphqlLogger).to receive(:info).with({
       trace_type: "execute_query",
       query_fingerprint: query.fingerprint,
-      duration_s: be > 0,
-      operation_name: 'fooOperation',
       operation_fingerprint: query.operation_fingerprint,
       is_mutation: false,
-      variables: variables.to_s,
-      query_string: query_string,
       "correlation_id" => anything,
       "meta.caller_id" => "caller_a",
       "meta.feature_category" => "feature_a",
diff --git a/spec/requests/api/graphql_spec.rb b/spec/requests/api/graphql_spec.rb
index 727220da53bbab..003919ccf0e73f 100644
--- a/spec/requests/api/graphql_spec.rb
+++ b/spec/requests/api/graphql_spec.rb
@@ -29,14 +29,10 @@
           "query_analysis.query_string" => query,
           # query_fingerprint starts with operation name
           query_fingerprint: %r{^anonymous\/},
-          duration_s: kind_of(Numeric),
           trace_type: 'execute_query',
-          operation_name: nil,
           # operation_fingerprint starts with operation name
           operation_fingerprint: %r{^anonymous\/},
-          is_mutation: false,
-          variables: variables.to_s,
-          query_string: query
+          is_mutation: false
         }
       end
 
-- 
GitLab


From 2f52ff35e413fb6a17fef2c9fc3866f42e6156dd Mon Sep 17 00:00:00 2001
From: Brett Walker <bwalker@gitlab.com>
Date: Fri, 27 May 2022 16:31:22 -0500
Subject: [PATCH 08/14] Remove unnecessary ENV['DEBUG_GRAPHQL']

---
 app/graphql/gitlab_schema.rb | 26 +++++++++++---------------
 1 file changed, 11 insertions(+), 15 deletions(-)

diff --git a/app/graphql/gitlab_schema.rb b/app/graphql/gitlab_schema.rb
index eb5f6d4f24004c..7a08bd3de703f6 100644
--- a/app/graphql/gitlab_schema.rb
+++ b/app/graphql/gitlab_schema.rb
@@ -10,21 +10,17 @@ class GitlabSchema < GraphQL::Schema
   DEFAULT_MAX_DEPTH = 15
   AUTHENTICATED_MAX_DEPTH = 20
 
-  if ENV['DEBUG_GRAPHQL']
-    use Gitlab::Graphql::Timeout, max_seconds: 1200
-  else
-    # Tracers (order is important)
-    use Gitlab::Graphql::Tracers::ApplicationContextTracer
-    use Gitlab::Graphql::Tracers::MetricsTracer
-    use Gitlab::Graphql::Tracers::LoggerTracer
-
-    # 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 Gitlab::Graphql::Timeout, max_seconds: Gitlab.config.gitlab.graphql_timeout
-  end
+  # Tracers (order is important)
+  use Gitlab::Graphql::Tracers::ApplicationContextTracer
+  use Gitlab::Graphql::Tracers::MetricsTracer
+  use Gitlab::Graphql::Tracers::LoggerTracer
+
+  # 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 Gitlab::Graphql::Timeout, max_seconds: Gitlab.config.gitlab.graphql_timeout
 
   use GraphQL::Subscriptions::ActionCableSubscriptions
   use BatchLoader::GraphQL
-- 
GitLab


From 49f8fe8f6edd10a7b9f46f943247387665e9aa4e Mon Sep 17 00:00:00 2001
From: Brett Walker <bwalker@gitlab.com>
Date: Tue, 31 May 2022 15:56:28 -0500
Subject: [PATCH 09/14] Add clarification comment in status_action_type.rb

---
 app/graphql/types/ci/status_action_type.rb | 1 +
 1 file changed, 1 insertion(+)

diff --git a/app/graphql/types/ci/status_action_type.rb b/app/graphql/types/ci/status_action_type.rb
index fa7ef92dbb586c..c0f61cf49f2f02 100644
--- a/app/graphql/types/ci/status_action_type.rb
+++ b/app/graphql/types/ci/status_action_type.rb
@@ -21,6 +21,7 @@ class StatusActionType < BaseObject
             description: 'Title for the action, for example: Retry.'
 
       def id(parent:)
+        # parent is a SimpleDelegator
         "#{parent.subject.class.name}-#{parent.id}"
       end
 
-- 
GitLab


From ef1b520c347479e8157725bd813dececa004c2e8 Mon Sep 17 00:00:00 2001
From: Brett Walker <bwalker@gitlab.com>
Date: Tue, 31 May 2022 15:57:16 -0500
Subject: [PATCH 10/14] Adjust loggers to original output

---
 .../query_analyzers/ast/logger_analyzer.rb    | 10 ++-------
 lib/gitlab/graphql/tracers/logger_tracer.rb   |  6 +++++-
 .../ast/logger_analyzer_spec.rb               |  1 -
 .../graphql/tracers/logger_tracer_spec.rb     | 21 ++++++++++---------
 spec/requests/api/graphql_spec.rb             |  9 ++++----
 5 files changed, 23 insertions(+), 24 deletions(-)

diff --git a/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer.rb b/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer.rb
index 8220523ff65f83..18f1cf50432736 100644
--- a/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer.rb
+++ b/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer.rb
@@ -15,10 +15,7 @@ def initialize(query)
 
             variables = process_variables(query.provided_variables)
             @results = default_initial_values(query).merge({
-              operation_name: query.operation_name,
-              query_string: query.query_string,
-              time_started: Gitlab::Metrics::System.monotonic_time,
-              variables: variables
+              time_started: Gitlab::Metrics::System.monotonic_time
             })
           rescue StandardError => e
             Gitlab::ErrorTracking.track_and_raise_for_dev_exception(e)
@@ -33,7 +30,7 @@ def result
             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]).round(1)
+            results[:duration_s] = duration(results[:time_started])
             results[:used_fields] = field_usages[:used_fields]
             results[:used_deprecated_fields] = field_usages[:used_deprecated_fields]
 
@@ -68,9 +65,6 @@ def duration(time_started)
           def default_initial_values(query)
             {
               time_started: Gitlab::Metrics::System.monotonic_time,
-              query_string: nil,
-              query: query,
-              variables: nil,
               duration_s: nil
             }
           end
diff --git a/lib/gitlab/graphql/tracers/logger_tracer.rb b/lib/gitlab/graphql/tracers/logger_tracer.rb
index 32b898f94c38ac..3302b2bae3f77c 100644
--- a/lib/gitlab/graphql/tracers/logger_tracer.rb
+++ b/lib/gitlab/graphql/tracers/logger_tracer.rb
@@ -32,8 +32,12 @@ def log_execute_query(query: nil, duration_s: 0, exception: nil)
           info = {
             trace_type: 'execute_query',
             query_fingerprint: query.fingerprint,
+            duration_s: duration_s,
+            operation_name: query.operation_name,
             operation_fingerprint: query.operation_fingerprint,
-            is_mutation: query.mutation?
+            is_mutation: query.mutation?,
+            variables: clean_variables(query.provided_variables),
+            query_string: query.query_string
           }
 
           Gitlab::ExceptionLogFormatter.format!(exception, info)
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
index eba6e96c649470..c9b24c6ee6fc63 100644
--- a/spec/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer_spec.rb
+++ b/spec/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer_spec.rb
@@ -34,7 +34,6 @@
       result = GraphQL::Analysis::AST.analyze_query(query, [described_class], multiplex_analyzers: [])
 
       expect(result.first[:duration_s]).to eq monotonic_time_duration
-      expect(result.first[:variables]).to eq '{:body=>"[FILTERED]"}'
       expect(result.first[:depth]).to eq 3
       expect(result.first[:complexity]).to eq 3
       expect(result.first[:used_fields]).to eq ['Note.id', 'CreateNotePayload.note', 'Mutation.createNote']
diff --git a/spec/lib/gitlab/graphql/tracers/logger_tracer_spec.rb b/spec/lib/gitlab/graphql/tracers/logger_tracer_spec.rb
index f7437524dc4a22..20792fb45541b1 100644
--- a/spec/lib/gitlab/graphql/tracers/logger_tracer_spec.rb
+++ b/spec/lib/gitlab/graphql/tracers/logger_tracer_spec.rb
@@ -20,7 +20,7 @@
     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) }'
 
@@ -28,21 +28,22 @@
     query = GraphQL::Query.new(dummy_schema, query_string, variables: variables)
 
     expect(::Gitlab::GraphqlLogger).to receive(:info).with({
-      trace_type: "execute_query",
-      query_fingerprint: query.fingerprint,
-      operation_fingerprint: query.operation_fingerprint,
-      is_mutation: false,
       "correlation_id" => anything,
       "meta.caller_id" => "caller_a",
       "meta.feature_category" => "feature_a",
-      "query_analysis.query_string" => query_string,
-      "query_analysis.variables" => variables.to_s,
       "query_analysis.duration_s" => kind_of(Numeric),
-      "query_analysis.operation_name" => 'fooOperation',
-      "query_analysis.depth" => 1,
       "query_analysis.complexity" => 1,
+      "query_analysis.depth" => 1,
+      "query_analysis.used_deprecated_fields" => [],
       "query_analysis.used_fields" => ["FakeQuery.helloWorld"],
-      "query_analysis.used_deprecated_fields" => []
+      duration_s: be > 0,
+      is_mutation: false,
+      operation_fingerprint: query.operation_fingerprint,
+      operation_name: 'fooOperation',
+      query_fingerprint: query.fingerprint,
+      query_string: query_string,
+      trace_type: "execute_query",
+      variables: variables.to_s
     })
 
     dummy_schema.execute(query_string, variables: variables)
diff --git a/spec/requests/api/graphql_spec.rb b/spec/requests/api/graphql_spec.rb
index 003919ccf0e73f..d94257c61eb726 100644
--- a/spec/requests/api/graphql_spec.rb
+++ b/spec/requests/api/graphql_spec.rb
@@ -24,15 +24,16 @@
           "query_analysis.complexity" => 1,
           "query_analysis.used_fields" => ['Query.echo'],
           "query_analysis.used_deprecated_fields" => [],
-          "query_analysis.variables" => variables.to_s,
-          "query_analysis.operation_name" => nil,
-          "query_analysis.query_string" => query,
           # query_fingerprint starts with operation name
           query_fingerprint: %r{^anonymous\/},
+          duration_s: kind_of(Numeric),
           trace_type: 'execute_query',
+          operation_name: nil,
           # operation_fingerprint starts with operation name
           operation_fingerprint: %r{^anonymous\/},
-          is_mutation: false
+          is_mutation: false,
+          variables: variables.to_s,
+          query_string: query
         }
       end
 
-- 
GitLab


From 992329d6d194a06ba50cc32039ff1a21e7e4a72e Mon Sep 17 00:00:00 2001
From: Brett Walker <bwalker@gitlab.com>
Date: Tue, 31 May 2022 18:06:47 -0500
Subject: [PATCH 11/14] Minor refactors based on suggestions

---
 app/graphql/gitlab_schema.rb       | 3 +--
 app/graphql/types/time_type.rb     | 1 +
 spec/graphql/gitlab_schema_spec.rb | 9 +--------
 3 files changed, 3 insertions(+), 10 deletions(-)

diff --git a/app/graphql/gitlab_schema.rb b/app/graphql/gitlab_schema.rb
index 7a08bd3de703f6..b399f0490eeeee 100644
--- a/app/graphql/gitlab_schema.rb
+++ b/app/graphql/gitlab_schema.rb
@@ -20,11 +20,10 @@ class GitlabSchema < GraphQL::Schema
   use Gitlab::Graphql::GenericTracing
   use Gitlab::Graphql::Tracers::TimerTracer
 
-  use Gitlab::Graphql::Timeout, max_seconds: Gitlab.config.gitlab.graphql_timeout
-
   use GraphQL::Subscriptions::ActionCableSubscriptions
   use BatchLoader::GraphQL
   use Gitlab::Graphql::Pagination::Connections
+  use Gitlab::Graphql::Timeout, max_seconds: Gitlab.config.gitlab.graphql_timeout
 
   query_analyzer Gitlab::Graphql::QueryAnalyzers::AST::LoggerAnalyzer
   query_analyzer Gitlab::Graphql::QueryAnalyzers::AST::RecursionAnalyzer
diff --git a/app/graphql/types/time_type.rb b/app/graphql/types/time_type.rb
index 40b097231de353..121515c04dbb91 100644
--- a/app/graphql/types/time_type.rb
+++ b/app/graphql/types/time_type.rb
@@ -12,6 +12,7 @@ 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)
diff --git a/spec/graphql/gitlab_schema_spec.rb b/spec/graphql/gitlab_schema_spec.rb
index 0fbfca2f5fd0ce..60b3edfc2791b4 100644
--- a/spec/graphql/gitlab_schema_spec.rb
+++ b/spec/graphql/gitlab_schema_spec.rb
@@ -4,6 +4,7 @@
 
 RSpec.describe GitlabSchema do
   let_it_be(:connections) { GitlabSchema.connections.all_wrappers }
+  let_it_be(:tracers) { described_class.tracers }
 
   let(:user) { build :user }
 
@@ -310,12 +311,4 @@ def initialize(id)
       end
     end
   end
-
-  def field_instrumenters
-    described_class.instrumenters[:field] + described_class.instrumenters[:field_after_built_ins]
-  end
-
-  def tracers
-    described_class.tracers
-  end
 end
-- 
GitLab


From 1afb3e9271d7cae769223fe06e08eb2252a34f15 Mon Sep 17 00:00:00 2001
From: Brett Walker <bwalker@gitlab.com>
Date: Tue, 31 May 2022 20:01:57 -0500
Subject: [PATCH 12/14] Fix flakiness due to dates

and adjust spec for correct fields being returned from
Gitlab::Graphql::QueryAnalyzers::AST::LoggerAnalyzer
---
 spec/controllers/graphql_controller_spec.rb | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/spec/controllers/graphql_controller_spec.rb b/spec/controllers/graphql_controller_spec.rb
index ae6fddd60f12f7..e85f5b7a972ef3 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 }
@@ -363,9 +366,7 @@
           depth: 2,
           used_deprecated_fields: [],
           used_fields: ['Project.id', 'Project.name', 'Query.project'],
-          variables: '{}',
-          query_string: "query getProject_1{ project(fullPath: \"foo\"){\n  id\nname\n}\n }",
-          duration_s: 0.0
+          variables: '{}'
         },
         {
           operation_name: 'getProject_2',
@@ -373,9 +374,7 @@
           depth: 2,
           used_deprecated_fields: [],
           used_fields: ['Project.id', 'Query.project'],
-          variables: '{}',
-          query_string: "query getProject_2{ project(fullPath: \"bar\"){\n  id\n}\n }",
-          duration_s: 0.0
+          variables: '{}'
         }
       ]
     end
-- 
GitLab


From 169c6d2cb25a814713b50c6410d7cdccb7f36838 Mon Sep 17 00:00:00 2001
From: Brett Walker <bwalker@gitlab.com>
Date: Tue, 31 May 2022 20:44:23 -0500
Subject: [PATCH 13/14] Set RequestStore same as the old logger does

since it was refactored.
---
 .../query_analyzers/ast/logger_analyzer.rb    | 19 +++++++++++++++---
 .../ast/logger_analyzer_spec.rb               | 20 +++++++++++++------
 2 files changed, 30 insertions(+), 9 deletions(-)

diff --git a/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer.rb b/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer.rb
index 18f1cf50432736..9a7069249ec3a7 100644
--- a/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer.rb
+++ b/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer.rb
@@ -13,7 +13,6 @@ class LoggerAnalyzer < GraphQL::Analysis::AST::Analyzer
           def initialize(query)
             super
 
-            variables = process_variables(query.provided_variables)
             @results = default_initial_values(query).merge({
               time_started: Gitlab::Metrics::System.monotonic_time
             })
@@ -34,8 +33,7 @@ def result
             results[:used_fields] = field_usages[:used_fields]
             results[:used_deprecated_fields] = field_usages[:used_deprecated_fields]
 
-            RequestStore.store[:graphql_logs] ||= []
-            RequestStore.store[:graphql_logs] << results
+            push_to_request_store(results)
 
             # This gl_analysis is included in the tracer log
             query.context[:gl_analysis] = results.except!(:time_started, :query)
@@ -47,6 +45,21 @@ def result
 
           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
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
index c9b24c6ee6fc63..a5274d49fdbced 100644
--- a/spec/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer_spec.rb
+++ b/spec/lib/gitlab/graphql/query_analyzers/ast/logger_analyzer_spec.rb
@@ -31,13 +31,21 @@
     end
 
     it 'returns the complexity, depth, duration, etc' do
-      result = GraphQL::Analysis::AST.analyze_query(query, [described_class], multiplex_analyzers: [])
+      results = GraphQL::Analysis::AST.analyze_query(query, [described_class], multiplex_analyzers: [])
+      result = results.first
 
-      expect(result.first[:duration_s]).to eq monotonic_time_duration
-      expect(result.first[:depth]).to eq 3
-      expect(result.first[:complexity]).to eq 3
-      expect(result.first[:used_fields]).to eq ['Note.id', 'CreateNotePayload.note', 'Mutation.createNote']
-      expect(RequestStore.store[:graphql_logs]).to eq result
+      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
-- 
GitLab


From e9d56ab64614a6d644e807a06de576acc02eb508 Mon Sep 17 00:00:00 2001
From: Brett Walker <bwalker@gitlab.com>
Date: Tue, 31 May 2022 20:56:36 -0500
Subject: [PATCH 14/14] =?UTF-8?q?Use=20query=5Fdouble=20instead=20of=20dou?=
 =?UTF-8?q?ble(=E2=80=98query=E2=80=99)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

so that it can be constructed properly
---
 spec/graphql/mutations/branches/create_spec.rb              | 4 +++-
 spec/graphql/mutations/clusters/agent_tokens/create_spec.rb | 4 +++-
 spec/graphql/mutations/clusters/agents/create_spec.rb       | 4 +++-
 spec/graphql/mutations/clusters/agents/delete_spec.rb       | 4 +++-
 spec/graphql/mutations/commits/create_spec.rb               | 4 +++-
 5 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/spec/graphql/mutations/branches/create_spec.rb b/spec/graphql/mutations/branches/create_spec.rb
index 9b92753a349176..5e9b914d87cb54 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 f60aa16c68c9c2..7998be19c2007c 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 62498357d681c0..e2c04254ed8301 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 ab01a2d93b8bfd..c3a2c0dcbb4bfe 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 456f6dc03f7e20..9fc9c731b969fb 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
     )
-- 
GitLab