graphql 1.9.0 → 2.1.1

data/lib/graphql/tracing/data_dog_trace.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    module DataDogTrace
+      # @param analytics_enabled [Boolean] Deprecated
+      # @param analytics_sample_rate [Float] Deprecated
+      def initialize(tracer: nil, analytics_enabled: false, analytics_sample_rate: 1.0, service: "ruby-graphql", **rest)
+        if tracer.nil?
+          tracer = defined?(Datadog::Tracing) ? Datadog::Tracing : Datadog.tracer
+        end
+        @tracer = tracer
+
+        analytics_available = defined?(Datadog::Contrib::Analytics) \
+            && Datadog::Contrib::Analytics.respond_to?(:enabled?) \
+            && Datadog::Contrib::Analytics.respond_to?(:set_sample_rate)
+
+        @analytics_enabled = analytics_available && Datadog::Contrib::Analytics.enabled?(analytics_enabled)
+        @analytics_sample_rate = analytics_sample_rate
+        @service_name = service
+        @has_prepare_span = respond_to?(:prepare_span)
+        super
+      end
+
+      {
+        'lex' => 'lex.graphql',
+        'parse' => 'parse.graphql',
+        'validate' => 'validate.graphql',
+        'analyze_query' => 'analyze.graphql',
+        'analyze_multiplex' => 'analyze.graphql',
+        'execute_multiplex' => 'execute.graphql',
+        'execute_query' => 'execute.graphql',
+        'execute_query_lazy' => 'execute.graphql',
+      }.each do |trace_method, trace_key|
+        module_eval <<-RUBY, __FILE__, __LINE__
+          def #{trace_method}(**data)
+            @tracer.trace("#{trace_key}", service: @service_name) do |span|
+              span.span_type = 'custom'
+              if defined?(Datadog::Tracing::Metadata::Ext) # Introduced in ddtrace 1.0
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, 'graphql')
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, '#{trace_method}')
+              end
+
+              #{
+                if trace_method == 'execute_multiplex'
+                  <<-RUBY
+                  operations = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
+
+                  resource = if operations.empty?
+                    first_query = data[:multiplex].queries.first
+                    fallback_transaction_name(first_query && first_query.context)
+                  else
+                    operations
+                  end
+                  span.resource = resource if resource
+
+                  # For top span of query, set the analytics sample rate tag, if available.
+                  if @analytics_enabled
+                    Datadog::Contrib::Analytics.set_sample_rate(span, @analytics_sample_rate)
+                  end
+                  RUBY
+                elsif trace_method == 'execute_query'
+                  <<-RUBY
+                  span.set_tag(:selected_operation_name, data[:query].selected_operation_name)
+                  span.set_tag(:selected_operation_type, data[:query].selected_operation.operation_type)
+                  span.set_tag(:query_string, data[:query].query_string)
+                  RUBY
+                end
+              }
+              if @has_prepare_span
+                prepare_span("#{trace_method.sub("platform_", "")}", data, span)
+              end
+              super
+            end
+          end
+        RUBY
+      end
+
+      def execute_field_span(span_key, query, field, ast_node, arguments, object)
+        return_type = field.type.unwrap
+        trace_field = if return_type.kind.scalar? || return_type.kind.enum?
+          (field.trace.nil? && @trace_scalars) || field.trace
+        else
+          true
+        end
+        platform_key = if trace_field
+          @platform_key_cache[DataDogTrace].platform_field_key_cache[field]
+        else
+          nil
+        end
+        if platform_key && trace_field
+          @tracer.trace(platform_key, service: @service_name) do |span|
+            span.span_type = 'custom'
+            if defined?(Datadog::Tracing::Metadata::Ext) # Introduced in ddtrace 1.0
+              span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, 'graphql')
+              span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, span_key)
+            end
+            if @has_prepare_span
+              prepare_span_data = { query: query, field: field, ast_node: ast_node, arguments: arguments, object: object }
+              prepare_span(span_key, prepare_span_data, span)
+            end
+            yield
+          end
+        else
+          yield
+        end
+      end
+      def execute_field(query:, field:, ast_node:, arguments:, object:)
+        execute_field_span("execute_field", query, field, ast_node, arguments, object) do
+          super(query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
+        end
+      end
+
+      def execute_field_lazy(query:, field:, ast_node:, arguments:, object:)
+        execute_field_span("execute_field_lazy", query, field, ast_node, arguments, object) do
+          super(query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
+        end
+      end
+
+      def authorized(query:, type:, object:)
+        authorized_span("authorized", object, type, query) do
+          super(query: query, type: type, object: object)
+        end
+      end
+
+      def authorized_span(span_key, object, type, query)
+        platform_key = @platform_key_cache[DataDogTrace].platform_authorized_key_cache[type]
+        @tracer.trace(platform_key, service: @service_name) do |span|
+          span.span_type = 'custom'
+          if defined?(Datadog::Tracing::Metadata::Ext) # Introduced in ddtrace 1.0
+            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, 'graphql')
+            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, span_key)
+          end
+          if @has_prepare_span
+            prepare_span(span_key, {object: object, type: type, query: query}, span)
+          end
+          yield
+        end
+      end
+
+      def authorized_lazy(object:, type:, query:)
+        authorized_span("authorized_lazy", object, type, query) do
+          super(query: query, type: type, object: object)
+        end
+      end
+
+      def resolve_type(object:, type:, query:)
+        resolve_type_span("resolve_type", object, type, query) do
+          super(object: object, query: query, type: type)
+        end
+      end
+
+      def resolve_type_lazy(object:, type:, query:)
+        resolve_type_span("resolve_type_lazy", object, type, query) do
+          super(object: object, query: query, type: type)
+        end
+      end
+
+      def resolve_type_span(span_key, object, type, query)
+        platform_key = @platform_key_cache[DataDogTrace].platform_resolve_type_key_cache[type]
+        @tracer.trace(platform_key, service: @service_name) do |span|
+          span.span_type = 'custom'
+          if defined?(Datadog::Tracing::Metadata::Ext) # Introduced in ddtrace 1.0
+            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, 'graphql')
+            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, span_key)
+          end
+          if @has_prepare_span
+            prepare_span(span_key, {object: object, type: type, query: query}, span)
+          end
+          yield
+        end
+      end
+
+      include PlatformTrace
+
+      # Implement this method in a subclass to apply custom tags to datadog spans
+      # @param key [String] The event being traced
+      # @param data [Hash] The runtime data for this event (@see GraphQL::Tracing for keys for each event)
+      # @param span [Datadog::Tracing::SpanOperation] The datadog span for this event
+      # def prepare_span(key, data, span)
+      # end
+
+      def platform_field_key(field)
+        field.path
+      end
+
+      def platform_authorized_key(type)
+        "#{type.graphql_name}.authorized"
+      end
+
+      def platform_resolve_type_key(type)
+        "#{type.graphql_name}.resolve_type"
+      end
+    end
+  end
+end

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -17,10 +17,26 @@ module GraphQL
       def platform_trace(platform_key, key, data)
         tracer.trace(platform_key, service: service_name) do |span|
           span.span_type = 'custom'
+          if defined?(Datadog::Tracing::Metadata::Ext) # Introduced in ddtrace 1.0
+            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, 'graphql')
+            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, key)
+          end
 
           if key == 'execute_multiplex'
             operations = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
-            span.resource = operations unless operations.empty?
+
+            resource = if operations.empty?
+              first_query = data[:multiplex].queries.first
+              fallback_transaction_name(first_query && first_query.context)
+            else
+              operations
+            end
+            span.resource = resource if resource
+
+            # For top span of query, set the analytics sample rate tag, if available.
+            if analytics_enabled?
+              Datadog::Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
+            end
           end
 
           if key == 'execute_query'
@@ -29,6 +45,8 @@ module GraphQL
             span.set_tag(:query_string, data[:query].query_string)
           end
 
+          prepare_span(key, data, span)
+
           yield
         end
       end
@@ -37,13 +55,46 @@ module GraphQL
         options.fetch(:service, 'ruby-graphql')
       end
 
+      # Implement this method in a subclass to apply custom tags to datadog spans
+      # @param key [String] The event being traced
+      # @param data [Hash] The runtime data for this event (@see GraphQL::Tracing for keys for each event)
+      # @param span [Datadog::Tracing::SpanOperation] The datadog span for this event
+      def prepare_span(key, data, span)
+      end
+
       def tracer
-        options.fetch(:tracer, Datadog.tracer)
+        default_tracer = defined?(Datadog::Tracing) ? Datadog::Tracing : Datadog.tracer
+
+        options.fetch(:tracer, default_tracer)
+      end
+
+      def analytics_available?
+        defined?(Datadog::Contrib::Analytics) \
+          && Datadog::Contrib::Analytics.respond_to?(:enabled?) \
+          && Datadog::Contrib::Analytics.respond_to?(:set_sample_rate)
+      end
+
+      def analytics_enabled?
+        # [Deprecated] options[:analytics_enabled] will be removed in the future
+        analytics_available? && Datadog::Contrib::Analytics.enabled?(options.fetch(:analytics_enabled, false))
+      end
+
+      def analytics_sample_rate
+        # [Deprecated] options[:analytics_sample_rate] will be removed in the future
+        options.fetch(:analytics_sample_rate, 1.0)
       end
 
       def platform_field_key(type, field)
         "#{type.graphql_name}.#{field.graphql_name}"
       end
+
+      def platform_authorized_key(type)
+        "#{type.graphql_name}.authorized"
+      end
+
+      def platform_resolve_type_key(type)
+        "#{type.graphql_name}.resolve_type"
+      end
     end
   end
 end

data/lib/graphql/tracing/legacy_trace.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+module GraphQL
+  module Tracing
+    # This trace class calls legacy-style tracer with payload hashes.
+    # New-style `trace_with` modules significantly reduce the overhead of tracing,
+    # but that advantage is lost when legacy-style tracers are also used (since the payload hashes are still constructed).
+    module CallLegacyTracers
+      def lex(query_string:)
+        (@multiplex || @query).trace("lex", { query_string: query_string }) { super }
+      end
+
+      def parse(query_string:)
+        (@multiplex || @query).trace("parse", { query_string: query_string }) { super }
+      end
+
+      def validate(query:, validate:)
+        query.trace("validate", { validate: validate, query: query }) { super }
+      end
+
+      def analyze_multiplex(multiplex:)
+        multiplex.trace("analyze_multiplex", { multiplex: multiplex }) { super }
+      end
+
+      def analyze_query(query:)
+        query.trace("analyze_query", { query: query }) { super }
+      end
+
+      def execute_multiplex(multiplex:)
+        multiplex.trace("execute_multiplex", { multiplex: multiplex }) { super }
+      end
+
+      def execute_query(query:)
+        query.trace("execute_query", { query: query }) { super }
+      end
+
+      def execute_query_lazy(query:, multiplex:)
+        multiplex.trace("execute_query_lazy", { multiplex: multiplex, query: query }) { super }
+      end
+
+      def execute_field(field:, query:, ast_node:, arguments:, object:)
+        query.trace("execute_field", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
+        query.trace("execute_field_lazy", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
+      end
+
+      def authorized(query:, type:, object:)
+        query.trace("authorized", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def authorized_lazy(query:, type:, object:)
+        query.trace("authorized_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def resolve_type(query:, type:, object:)
+        query.trace("resolve_type", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def resolve_type_lazy(query:, type:, object:)
+        query.trace("resolve_type_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+    end
+
+    class LegacyTrace < Trace
+      include CallLegacyTracers
+    end
+  end
+end

data/lib/graphql/tracing/new_relic_trace.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    module NewRelicTrace
+      include PlatformTrace
+
+      # @param set_transaction_name [Boolean] If true, the GraphQL operation name will be used as the transaction name.
+      #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
+      #   It can also be specified per-query with `context[:set_new_relic_transaction_name]`.
+      def initialize(set_transaction_name: false, **_rest)
+        @set_transaction_name = set_transaction_name
+        super
+      end
+
+      def execute_query(query:)
+        set_this_txn_name =  query.context[:set_new_relic_transaction_name]
+        if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
+          NewRelic::Agent.set_transaction_name(transaction_name(query))
+        end
+        NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped("GraphQL/execute") do
+          super
+        end
+      end
+
+      {
+        "lex" => "GraphQL/lex",
+        "parse" => "GraphQL/parse",
+        "validate" => "GraphQL/validate",
+        "analyze_query" => "GraphQL/analyze",
+        "analyze_multiplex" => "GraphQL/analyze",
+        "execute_multiplex" => "GraphQL/execute",
+        "execute_query_lazy" => "GraphQL/execute",
+      }.each do |trace_method, platform_key|
+        module_eval <<-RUBY, __FILE__, __LINE__
+          def #{trace_method}(**_keys)
+            NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped("#{platform_key}") do
+              super
+            end
+          end
+        RUBY
+      end
+
+      def platform_execute_field(platform_key)
+        NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped(platform_key) do
+          yield
+        end
+      end
+
+      def platform_authorized(platform_key)
+        NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped(platform_key) do
+          yield
+        end
+      end
+
+      def platform_resolve_type(platform_key)
+        NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped(platform_key) do
+          yield
+        end
+      end
+
+      def platform_field_key(field)
+        "GraphQL/#{field.owner.graphql_name}/#{field.graphql_name}"
+      end
+
+      def platform_authorized_key(type)
+        "GraphQL/Authorize/#{type.graphql_name}"
+      end
+
+      def platform_resolve_type_key(type)
+        "GraphQL/ResolveType/#{type.graphql_name}"
+      end
+    end
+  end
+end

data/lib/graphql/tracing/new_relic_tracing.rb

@@ -26,18 +26,7 @@ module GraphQL
         if key == "execute_query"
           set_this_txn_name =  data[:query].context[:set_new_relic_transaction_name]
           if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
-            query = data[:query]
-            # Set the transaction name based on the operation type and name
-            selected_op = query.selected_operation
-            if selected_op
-              op_type = selected_op.operation_type
-              op_name = selected_op.name || "anonymous"
-            else
-              op_type = "query"
-              op_name = "anonymous"
-            end
-
-            NewRelic::Agent.set_transaction_name("GraphQL/#{op_type}.#{op_name}")
+            NewRelic::Agent.set_transaction_name(transaction_name(data[:query]))
           end
         end
 
@@ -49,6 +38,14 @@ module GraphQL
       def platform_field_key(type, field)
         "GraphQL/#{type.graphql_name}/#{field.graphql_name}"
       end
+
+      def platform_authorized_key(type)
+        "GraphQL/Authorize/#{type.graphql_name}"
+      end
+
+      def platform_resolve_type_key(type)
+        "GraphQL/ResolveType/#{type.graphql_name}"
+      end
     end
   end
 end

data/lib/graphql/tracing/notifications_trace.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "graphql/tracing/platform_trace"
+
+module GraphQL
+  module Tracing
+    # This implementation forwards events to a notification handler (i.e.
+    # ActiveSupport::Notifications or Dry::Monitor::Notifications)
+    # with a `graphql` suffix.
+    module NotificationsTrace
+      # Initialize a new NotificationsTracing instance
+      #
+      # @param engine [#instrument(key, metadata, block)] The notifications engine to use
+      def initialize(engine:, **rest)
+        @notifications_engine = engine
+        super
+      end
+
+      {
+        "lex" => "lex.graphql",
+        "parse" => "parse.graphql",
+        "validate" => "validate.graphql",
+        "analyze_multiplex" => "analyze_multiplex.graphql",
+        "analyze_query" => "analyze_query.graphql",
+        "execute_multiplex" => "execute_multiplex.graphql",
+        "execute_query" => "execute_query.graphql",
+        "execute_query_lazy" => "execute_query_lazy.graphql",
+        "execute_field" => "execute_field.graphql",
+        "execute_field_lazy" => "execute_field_lazy.graphql",
+        "authorized" => "authorized.graphql",
+        "authorized_lazy" => "authorized_lazy.graphql",
+        "resolve_type" => "resolve_type.graphql",
+        "resolve_type_lazy" => "resolve_type.graphql",
+      }.each do |trace_method, platform_key|
+        module_eval <<-RUBY, __FILE__, __LINE__
+          def #{trace_method}(**metadata, &blk)
+            @notifications_engine.instrument("#{platform_key}", metadata, &blk)
+          end
+        RUBY
+      end
+
+      include PlatformTrace
+    end
+  end
+end

data/lib/graphql/tracing/notifications_tracing.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    # This implementation forwards events to a notification handler (i.e.
+    # ActiveSupport::Notifications or Dry::Monitor::Notifications)
+    # with a `graphql` suffix.
+    #
+    # @see KEYS for event names
+    class NotificationsTracing
+      # A cache of frequently-used keys to avoid needless string allocations
+      KEYS = {
+        "lex" => "lex.graphql",
+        "parse" => "parse.graphql",
+        "validate" => "validate.graphql",
+        "analyze_multiplex" => "analyze_multiplex.graphql",
+        "analyze_query" => "analyze_query.graphql",
+        "execute_query" => "execute_query.graphql",
+        "execute_query_lazy" => "execute_query_lazy.graphql",
+        "execute_field" => "execute_field.graphql",
+        "execute_field_lazy" => "execute_field_lazy.graphql",
+        "authorized" => "authorized.graphql",
+        "authorized_lazy" => "authorized_lazy.graphql",
+        "resolve_type" => "resolve_type.graphql",
+        "resolve_type_lazy" => "resolve_type.graphql",
+      }
+
+      MAX_KEYS_SIZE = 100
+
+      # Initialize a new NotificationsTracing instance
+      #
+      # @param [Object] notifications_engine The notifications engine to use
+      def initialize(notifications_engine)
+        @notifications_engine = notifications_engine
+      end
+
+      # Sends a GraphQL tracing event to the notification handler
+      #
+      # @example
+      # . notifications_engine = Dry::Monitor::Notifications.new(:graphql)
+      # . tracer = GraphQL::Tracing::NotificationsTracing.new(notifications_engine)
+      # . tracer.trace("lex") { ... }
+      #
+      # @param [string] key The key for the event
+      # @param [Hash] metadata The metadata for the event
+      # @yield The block to execute for the event
+      def trace(key, metadata, &blk)
+        prefixed_key = KEYS[key] || "#{key}.graphql"
+
+        # Cache the new keys while making sure not to induce a memory leak
+        if KEYS.size < MAX_KEYS_SIZE
+          KEYS[key] ||= prefixed_key
+        end
+
+        @notifications_engine.instrument(prefixed_key, metadata, &blk)
+      end
+    end
+  end
+end

data/lib/graphql/tracing/platform_trace.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    module PlatformTrace
+      def initialize(trace_scalars: false, **_options)
+        @trace_scalars = trace_scalars
+
+        @platform_key_cache = Hash.new { |h, mod| h[mod] = mod::KeyCache.new }
+        super
+      end
+
+      module BaseKeyCache
+        def initialize
+          @platform_field_key_cache = Hash.new { |h, k| h[k] = platform_field_key(k) }
+          @platform_authorized_key_cache = Hash.new { |h, k| h[k] = platform_authorized_key(k) }
+          @platform_resolve_type_key_cache = Hash.new { |h, k| h[k] = platform_resolve_type_key(k) }
+        end
+
+        attr_reader :platform_field_key_cache, :platform_authorized_key_cache, :platform_resolve_type_key_cache
+      end
+
+
+      def platform_execute_field_lazy(*args, &block)
+        platform_execute_field(*args, &block)
+      end
+
+      def platform_authorized_lazy(key, &block)
+        platform_authorized(key, &block)
+      end
+
+      def platform_resolve_type_lazy(key, &block)
+        platform_resolve_type(key, &block)
+      end
+
+      def self.included(child_class)
+        key_methods_class = Class.new {
+          include(child_class)
+          include(BaseKeyCache)
+        }
+        child_class.const_set(:KeyCache, key_methods_class)
+        [:execute_field, :execute_field_lazy].each do |field_trace_method|
+          if !child_class.method_defined?(field_trace_method)
+            child_class.module_eval <<-RUBY, __FILE__, __LINE__
+              def #{field_trace_method}(query:, field:, ast_node:, arguments:, object:)
+                return_type = field.type.unwrap
+                trace_field = if return_type.kind.scalar? || return_type.kind.enum?
+                  (field.trace.nil? && @trace_scalars) || field.trace
+                else
+                  true
+                end
+                platform_key = if trace_field
+                  @platform_key_cache[#{child_class}].platform_field_key_cache[field]
+                else
+                  nil
+                end
+                if platform_key && trace_field
+                  platform_#{field_trace_method}(platform_key) do
+                    super
+                  end
+                else
+                  super
+                end
+              end
+            RUBY
+          end
+        end
+
+
+        [:authorized, :authorized_lazy].each do |auth_trace_method|
+          if !child_class.method_defined?(auth_trace_method)
+            child_class.module_eval <<-RUBY, __FILE__, __LINE__
+              def #{auth_trace_method}(type:, query:, object:)
+                platform_key = @platform_key_cache[#{child_class}].platform_authorized_key_cache[type]
+                platform_#{auth_trace_method}(platform_key) do
+                  super
+                end
+              end
+            RUBY
+          end
+        end
+
+        [:resolve_type, :resolve_type_lazy].each do |rt_trace_method|
+          if !child_class.method_defined?(rt_trace_method)
+            child_class.module_eval <<-RUBY, __FILE__, __LINE__
+              def #{rt_trace_method}(query:, type:, object:)
+                platform_key = @platform_key_cache[#{child_class}].platform_resolve_type_key_cache[type]
+                platform_#{rt_trace_method}(platform_key) do
+                  super
+                end
+              end
+            RUBY
+          end
+        end
+      end
+
+      private
+
+      # Get the transaction name based on the operation type and name if possible, or fall back to a user provided
+      # one. Useful for anonymous queries.
+      def transaction_name(query)
+        selected_op = query.selected_operation
+        txn_name = if selected_op
+          op_type = selected_op.operation_type
+          op_name = selected_op.name || fallback_transaction_name(query.context) || "anonymous"
+          "#{op_type}.#{op_name}"
+        else
+          "query.anonymous"
+        end
+        "GraphQL/#{txn_name}"
+      end
+
+      def fallback_transaction_name(context)
+        context[:tracing_fallback_transaction_name]
+      end
+    end
+  end
+end