graphql 2.4.15 → 2.5.0

data/lib/graphql/tracing/prometheus_trace.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "graphql/tracing/platform_trace"
+require "graphql/tracing/monitor_trace"
 
 module GraphQL
   module Tracing
@@ -26,93 +26,66 @@ module GraphQL
     #
     #    # Then run:
     #    # bundle exec prometheus_exporter -a lib/graphql_collector.rb
+    PrometheusTrace = MonitorTrace.create_module("prometheus")
     module PrometheusTrace
       if defined?(PrometheusExporter::Server)
         autoload :GraphQLCollector, "graphql/tracing/prometheus_trace/graphql_collector"
       end
-      include PlatformTrace
 
-      def initialize(client: PrometheusExporter::Client.default, keys_whitelist: ["execute_field", "execute_field_lazy"], collector_type: "graphql", **rest)
-        @client = client
-        @keys_whitelist = keys_whitelist
-        @collector_type = collector_type
-
-        super(**rest)
+      def initialize(client: PrometheusExporter::Client.default, keys_whitelist: [:execute_field], collector_type: "graphql", **rest)
+        @prometheus_client = client
+        @prometheus_keys_whitelist = keys_whitelist.map(&:to_sym) # handle previous string keys
+        @prometheus_collector_type = collector_type
+        setup_prometheus_monitor(**rest)
+        super
       end
 
-      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
-
-      {
-        'lex' => "graphql.lex",
-        'parse' => "graphql.parse",
-        'validate' => "graphql.validate",
-        'analyze_query' => "graphql.analyze",
-        'analyze_multiplex' => "graphql.analyze",
-        'execute_multiplex' => "graphql.execute",
-        'execute_query' => "graphql.execute",
-        'execute_query_lazy' => "graphql.execute",
-      }.each do |trace_method, platform_key|
-        module_eval <<-RUBY, __FILE__, __LINE__
-          def #{trace_method}(**data)
-            instrument_prometheus_execution("#{platform_key}", "#{trace_method}") { super }
+      attr_reader :prometheus_collector_type, :prometheus_client, :prometheus_keys_whitelist
+
+      class PrometheusMonitor < MonitorTrace::Monitor
+        def instrument(keyword, object)
+          if active?(keyword)
+            start = gettime
+            result = yield
+            duration = gettime - start
+            send_json(duration, keyword, object)
+            result
+          else
+            yield
           end
-        RUBY
-      end
-
-      # rubocop:enable Development/NoEvalCop
-
-      def platform_execute_field(platform_key, &block)
-        instrument_prometheus_execution(platform_key, "execute_field", &block)
-      end
-
-      def platform_execute_field_lazy(platform_key, &block)
-        instrument_prometheus_execution(platform_key, "execute_field_lazy", &block)
-      end
-
-      def platform_authorized(platform_key, &block)
-        instrument_prometheus_execution(platform_key, "authorized", &block)
-      end
-
-      def platform_authorized_lazy(platform_key, &block)
-        instrument_prometheus_execution(platform_key, "authorized_lazy", &block)
-      end
-
-      def platform_resolve_type(platform_key, &block)
-        instrument_prometheus_execution(platform_key, "resolve_type", &block)
-      end
+        end
 
-      def platform_resolve_type_lazy(platform_key, &block)
-        instrument_prometheus_execution(platform_key, "resolve_type_lazy", &block)
-      end
+        def active?(keyword)
+          @trace.prometheus_keys_whitelist.include?(keyword)
+        end
 
-      def platform_field_key(field)
-        field.path
-      end
+        def gettime
+          ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        end
 
-      def platform_authorized_key(type)
-        "#{type.graphql_name}.authorized"
-      end
+        def send_json(duration, keyword, object)
+          event_name = name_for(keyword, object)
+          @trace.prometheus_client.send_json(
+            type: @trace.prometheus_collector_type,
+            duration: duration,
+            platform_key: event_name,
+            key: keyword
+          )
+        end
 
-      def platform_resolve_type_key(type)
-        "#{type.graphql_name}.resolve_type"
-      end
+        include MonitorTrace::Monitor::GraphQLPrefixNames
 
-      private
+        class Event < MonitorTrace::Monitor::Event
+          def start
+            @start_time = @monitor.gettime
+          end
 
-      def instrument_prometheus_execution(platform_key, key, &block)
-        if @keys_whitelist.include?(key)
-          start = ::Process.clock_gettime ::Process::CLOCK_MONOTONIC
-          result = block.call
-          duration = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start
-          @client.send_json(
-            type: @collector_type,
-            duration: duration,
-            platform_key: platform_key,
-            key: key
-          )
-          result
-        else
-          yield
+          def finish
+            if @monitor.active?(keyword)
+              duration = @monitor.gettime - @start_time
+              @monitor.send_json(duration, keyword, object)
+            end
+          end
         end
       end
     end

data/lib/graphql/tracing/scout_trace.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "graphql/tracing/platform_trace"
+require "graphql/tracing/monitor_trace"
 
 module GraphQL
   module Tracing
@@ -10,73 +10,39 @@ module GraphQL
     #   class MySchema < GraphQL::Schema
     #     trace_with GraphQL::Tracing::ScoutTrace
     #   end
+    ScoutTrace = MonitorTrace.create_module("scout")
     module ScoutTrace
-      include PlatformTrace
-
-      INSTRUMENT_OPTS = { scope: true }
-
-      # @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_scout_transaction_name]`.
-      def initialize(set_transaction_name: false, **_rest)
-        self.class.include(ScoutApm::Tracer)
-        @set_transaction_name = set_transaction_name
-        super
-      end
-
-      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
-
-      {
-        "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, platform_key|
-        module_eval <<-RUBY, __FILE__, __LINE__
-        def #{trace_method}(**data)
-          #{
-            if trace_method == "execute_query"
-              <<-RUBY
-              set_this_txn_name = data[:query].context[:set_scout_transaction_name]
-              if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
-                ScoutApm::Transaction.rename(transaction_name(data[:query]))
-              end
-              RUBY
+      class ScoutMonitor < MonitorTrace::Monitor
+        def instrument(keyword, object)
+          if keyword == :execute
+            query = object.queries.first
+            set_this_txn_name = query.context[:set_scout_transaction_name]
+            if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
+              ScoutApm::Transaction.rename(transaction_name(query))
             end
-          }
+          end
 
-          self.class.instrument("GraphQL", "#{platform_key}", INSTRUMENT_OPTS) do
-            super
+          ScoutApm::Tracer.instrument("GraphQL", name_for(keyword, object), INSTRUMENT_OPTS) do
+            yield
           end
         end
-        RUBY
-      end
-      # rubocop:enable Development/NoEvalCop
-
-      def platform_execute_field(platform_key, &block)
-        self.class.instrument("GraphQL", platform_key, INSTRUMENT_OPTS, &block)
-      end
-
-      def platform_authorized(platform_key, &block)
-        self.class.instrument("GraphQL", platform_key, INSTRUMENT_OPTS, &block)
-      end
 
-      alias :platform_resolve_type :platform_authorized
+        INSTRUMENT_OPTS = { scope: true }
 
-      def platform_field_key(field)
-        field.path
-      end
+        include MonitorTrace::Monitor::GraphQLSuffixNames
 
-      def platform_authorized_key(type)
-        "#{type.graphql_name}.authorized"
-      end
+        class Event < MonitorTrace::Monitor::Event
+          def start
+            layer = ScoutApm::Layer.new("GraphQL", @monitor.name_for(keyword, object))
+            layer.subscopable!
+            @scout_req = ScoutApm::RequestManager.lookup
+            @scout_req.start_layer(layer)
+          end
 
-      def platform_resolve_type_key(type)
-        "#{type.graphql_name}.resolve_type"
+          def finish
+            @scout_req.stop_layer
+          end
+        end
       end
     end
   end

data/lib/graphql/tracing/sentry_trace.rb

@@ -1,121 +1,79 @@
 # frozen_string_literal: true
 
-require "graphql/tracing/platform_trace"
+require "graphql/tracing/monitor_trace"
 
 module GraphQL
   module Tracing
     # A tracer for reporting GraphQL-Ruby times to Sentry.
+    #
     # @example Installing the tracer
     #   class MySchema < GraphQL::Schema
     #     trace_with GraphQL::Tracing::SentryTrace
     #   end
+    # @see MonitorTrace Configuration Options in the parent module
+    SentryTrace = MonitorTrace.create_module("sentry")
     module SentryTrace
-      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_sentry_transaction_name]`.
-      def initialize(set_transaction_name: false, **_rest)
-        @set_transaction_name = set_transaction_name
-        super
-      end
-
-      def execute_query(**data)
-        set_this_txn_name = data[:query].context[:set_sentry_transaction_name]
-        if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
-          Sentry.configure_scope do |scope|
-            scope.set_transaction_name(transaction_name(data[:query]))
+      class SentryMonitor < MonitorTrace::Monitor
+        def instrument(keyword, object)
+          return yield unless Sentry.initialized?
+
+          platform_key = name_for(keyword, object)
+
+          Sentry.with_child_span(op: platform_key, start_timestamp: Sentry.utc_now.to_f) do |span|
+            result = yield
+            return result unless span
+
+            span.finish
+            if keyword == :execute
+              queries = object.queries
+              operation_names = queries.map{|q| operation_name(q) }
+              span.set_description(operation_names.join(", "))
+
+              if queries.size == 1
+                query = queries.first
+                set_this_txn_name = query.context[:set_sentry_transaction_name]
+                if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
+                  Sentry.configure_scope do |scope|
+                    scope.set_transaction_name(transaction_name(query))
+                  end
+                end
+                span.set_data('graphql.document', query.query_string)
+                if query.selected_operation_name
+                  span.set_data('graphql.operation.name', query.selected_operation_name)
+                end
+                span.set_data('graphql.operation.type', query.selected_operation.operation_type)
+              end
+            end
+
+            result
           end
         end
-        instrument_sentry_execution("graphql.execute", "execute_query", data) { super }
-      end
 
-      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+        include MonitorTrace::Monitor::GraphQLPrefixNames
 
-      {
-        "lex" => "graphql.lex",
-        "parse" => "graphql.parse",
-        "validate" => "graphql.validate",
-        "analyze_query" => "graphql.analyze",
-        "analyze_multiplex" => "graphql.analyze_multiplex",
-        "execute_multiplex" => "graphql.execute_multiplex",
-        "execute_query_lazy" => "graphql.execute"
-      }.each do |trace_method, platform_key|
-        module_eval <<-RUBY, __FILE__, __LINE__
-        def #{trace_method}(**data)
-          instrument_sentry_execution("#{platform_key}", "#{trace_method}", data) { super }
-        end
-        RUBY
-      end
-
-      # rubocop:enable Development/NoEvalCop
-
-      def platform_execute_field(platform_key, &block)
-        instrument_sentry_execution(platform_key, "execute_field", &block)
-      end
-
-      def platform_execute_field_lazy(platform_key, &block)
-        instrument_sentry_execution(platform_key, "execute_field_lazy", &block)
-      end
-
-      def platform_authorized(platform_key, &block)
-        instrument_sentry_execution(platform_key, "authorized", &block)
-      end
-
-      def platform_authorized_lazy(platform_key, &block)
-        instrument_sentry_execution(platform_key, "authorized_lazy", &block)
-      end
-
-      def platform_resolve_type(platform_key, &block)
-        instrument_sentry_execution(platform_key, "resolve_type", &block)
-      end
+        private
 
-      def platform_resolve_type_lazy(platform_key, &block)
-        instrument_sentry_execution(platform_key, "resolve_type_lazy", &block)
-      end
-
-      def platform_field_key(field)
-        "graphql.field.#{field.path}"
-      end
-
-      def platform_authorized_key(type)
-        "graphql.authorized.#{type.graphql_name}"
-      end
-
-      def platform_resolve_type_key(type)
-        "graphql.resolve_type.#{type.graphql_name}"
-      end
-
-      private
-
-      def instrument_sentry_execution(platform_key, trace_method, data=nil, &block)
-        return yield unless Sentry.initialized?
-
-        Sentry.with_child_span(op: platform_key, start_timestamp: Sentry.utc_now.to_f) do |span|
-          result = yield
-          return result unless span
-
-          span.finish
-          if trace_method == "execute_multiplex" && data.key?(:multiplex)
-            operation_names = data[:multiplex].queries.map{|q| operation_name(q) }
-            span.set_description(operation_names.join(", "))
-          elsif trace_method == "execute_query" && data.key?(:query)
-            span.set_description(operation_name(data[:query]))
-            span.set_data('graphql.document', data[:query].query_string)
-            span.set_data('graphql.operation.name', data[:query].selected_operation_name) if data[:query].selected_operation_name
-            span.set_data('graphql.operation.type', data[:query].selected_operation.operation_type)
+        def operation_name(query)
+          selected_op = query.selected_operation
+          if selected_op
+            [selected_op.operation_type, selected_op.name].compact.join(' ')
+          else
+            'GraphQL Operation'
           end
-
-          result
         end
-      end
 
-      def operation_name(query)
-        selected_op = query.selected_operation
-        if selected_op
-          [selected_op.operation_type, selected_op.name].compact.join(' ')
-        else
-          'GraphQL Operation'
+        class Event < MonitorTrace::Monitor::Event
+          def start
+            if Sentry.initialized?
+              @span = Sentry.get_current_scope.get_span
+              span_name = @monitor.name_for(@keyword, @object)
+              @span.start_child(op: span_name)
+            end
+          end
+
+          def finish
+            @span&.finish
+          end
         end
       end
     end

data/lib/graphql/tracing/statsd_trace.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-require "graphql/tracing/platform_trace"
+require "graphql/tracing/monitor_trace"
 
 module GraphQL
   module Tracing
     # A tracer for reporting GraphQL-Ruby times to Statsd.
-    # Passing any Statsd client that implements `.time(name) { ... }` will work.
+    # Passing any Statsd client that implements `.time(name) { ... }`
+    # and `.timing(name, ms)` will work.
     #
     # @example Installing this tracer
     #   # eg:
@@ -13,58 +14,34 @@ module GraphQL
     #   class MySchema < GraphQL::Schema
     #     use GraphQL::Tracing::StatsdTrace, statsd: $statsd
     #   end
+    StatsdTrace = MonitorTrace.create_module("statsd")
     module StatsdTrace
-      include PlatformTrace
+      class StatsdMonitor < MonitorTrace::Monitor
+        def initialize(statsd:, **_rest)
+          @statsd = statsd
+          super
+        end
 
-      # @param statsd [Object] A statsd client
-      def initialize(statsd:, **rest)
-        @statsd = statsd
-        super(**rest)
-      end
-
-      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+        attr_reader :statsd
 
-      {
-        'lex' => "graphql.lex",
-        'parse' => "graphql.parse",
-        'validate' => "graphql.validate",
-        'analyze_query' => "graphql.analyze_query",
-        'analyze_multiplex' => "graphql.analyze_multiplex",
-        'execute_multiplex' => "graphql.execute_multiplex",
-        'execute_query' => "graphql.execute_query",
-        'execute_query_lazy' => "graphql.execute_query_lazy",
-      }.each do |trace_method, platform_key|
-        module_eval <<-RUBY, __FILE__, __LINE__
-          def #{trace_method}(**data)
-            @statsd.time("#{platform_key}") do
-              super
-            end
+        def instrument(keyword, object)
+          @statsd.time(name_for(keyword, object)) do
+            yield
           end
-        RUBY
-      end
-
-      # rubocop:enable Development/NoEvalCop
+        end
 
-      def platform_execute_field(platform_key, &block)
-        @statsd.time(platform_key, &block)
-      end
-
-      def platform_authorized(key, &block)
-        @statsd.time(key, &block)
-      end
+        include MonitorTrace::Monitor::GraphQLPrefixNames
 
-      alias :platform_resolve_type :platform_authorized
-
-      def platform_field_key(field)
-        "graphql.#{field.path}"
-      end
-
-      def platform_authorized_key(type)
-        "graphql.authorized.#{type.graphql_name}"
-      end
+        class Event < MonitorTrace::Monitor::Event
+          def start
+            @start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          end
 
-      def platform_resolve_type_key(type)
-        "graphql.resolve_type.#{type.graphql_name}"
+          def finish
+            elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - @start_time
+            @monitor.statsd.timing(@monitor.name_for(keyword, object), elapsed)
+          end
+        end
       end
     end
   end

data/lib/graphql/tracing/trace.rb

@@ -23,12 +23,6 @@ module GraphQL
         yield
       end
 
-      # @param query_str [String]
-      # @return [void]
-      def begin_parse(query_str); end;
-      # @param query_str [String]
-      # @return [void]
-      def end_parse(query_str); end;
       # @param query_string [String]
       # @return [void]
       def parse(query_string:)
@@ -63,17 +57,6 @@ module GraphQL
         yield
       end
 
-      # This is the first event in the tracing lifecycle.
-      # Every Query is technically run _inside_ a {GraphQL::Multiplex}.
-      # @param multiplex [GraphQL::Execution::Multiplex]
-      # @return [void]
-      def begin_execute_multiplex(multiplex); end;
-
-      # This is the last event of the tracing lifecycle.
-      # @param multiplex [GraphQL::Execution::Multiplex]
-      # @return [void]
-      def end_execute_multiplex(multiplex); end;
-
       # This wraps an entire `.execute` call.
       # @param multiplex [GraphQL::Execution::Multiplex]
       # @return [void]

data/lib/graphql/tracing.rb

@@ -25,6 +25,7 @@ module GraphQL
     autoload :AppOpticsTrace, "graphql/tracing/appoptics_trace"
     autoload :AppsignalTrace, "graphql/tracing/appsignal_trace"
     autoload :DataDogTrace, "graphql/tracing/data_dog_trace"
+    autoload :MonitorTrace, "graphql/tracing/monitor_trace"
     autoload :NewRelicTrace, "graphql/tracing/new_relic_trace"
     autoload :NotificationsTrace, "graphql/tracing/notifications_trace"
     autoload :SentryTrace, "graphql/tracing/sentry_trace"

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "2.4.15"
+  VERSION = "2.5.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.4.15
+  version: 2.5.0
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2025-03-19 00:00:00.000000000 Z
+date: 2025-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -432,14 +432,33 @@ files:
 - lib/graphql/coercion_error.rb
 - lib/graphql/current.rb
 - lib/graphql/dashboard.rb
+- lib/graphql/dashboard/detailed_traces.rb
+- lib/graphql/dashboard/installable.rb
+- lib/graphql/dashboard/limiters.rb
+- lib/graphql/dashboard/operation_store.rb
 - lib/graphql/dashboard/statics/bootstrap-5.3.3.min.css
 - lib/graphql/dashboard/statics/bootstrap-5.3.3.min.js
+- lib/graphql/dashboard/statics/charts.min.css
 - lib/graphql/dashboard/statics/dashboard.css
 - lib/graphql/dashboard/statics/dashboard.js
 - lib/graphql/dashboard/statics/header-icon.png
 - lib/graphql/dashboard/statics/icon.png
+- lib/graphql/dashboard/subscriptions.rb
+- lib/graphql/dashboard/views/graphql/dashboard/detailed_traces/traces/index.html.erb
 - lib/graphql/dashboard/views/graphql/dashboard/landings/show.html.erb
-- lib/graphql/dashboard/views/graphql/dashboard/traces/index.html.erb
+- lib/graphql/dashboard/views/graphql/dashboard/limiters/limiters/show.html.erb
+- lib/graphql/dashboard/views/graphql/dashboard/not_installed.html.erb
+- lib/graphql/dashboard/views/graphql/dashboard/operation_store/clients/_form.html.erb
+- lib/graphql/dashboard/views/graphql/dashboard/operation_store/clients/edit.html.erb
+- lib/graphql/dashboard/views/graphql/dashboard/operation_store/clients/index.html.erb
+- lib/graphql/dashboard/views/graphql/dashboard/operation_store/clients/new.html.erb
+- lib/graphql/dashboard/views/graphql/dashboard/operation_store/index_entries/index.html.erb
+- lib/graphql/dashboard/views/graphql/dashboard/operation_store/index_entries/show.html.erb
+- lib/graphql/dashboard/views/graphql/dashboard/operation_store/operations/index.html.erb
+- lib/graphql/dashboard/views/graphql/dashboard/operation_store/operations/show.html.erb
+- lib/graphql/dashboard/views/graphql/dashboard/subscriptions/subscriptions/show.html.erb
+- lib/graphql/dashboard/views/graphql/dashboard/subscriptions/topics/index.html.erb
+- lib/graphql/dashboard/views/graphql/dashboard/subscriptions/topics/show.html.erb
 - lib/graphql/dashboard/views/layouts/graphql/dashboard/application.html.erb
 - lib/graphql/dataloader.rb
 - lib/graphql/dataloader/active_record_association_source.rb
@@ -657,6 +676,7 @@ files:
 - lib/graphql/static_validation/rules/mutation_root_exists_error.rb
 - lib/graphql/static_validation/rules/no_definitions_are_present.rb
 - lib/graphql/static_validation/rules/no_definitions_are_present_error.rb
+- lib/graphql/static_validation/rules/not_single_subscription_error.rb
 - lib/graphql/static_validation/rules/one_of_input_objects_are_valid.rb
 - lib/graphql/static_validation/rules/one_of_input_objects_are_valid_error.rb
 - lib/graphql/static_validation/rules/operation_names_are_valid.rb
@@ -667,7 +687,7 @@ files:
 - lib/graphql/static_validation/rules/required_arguments_are_present_error.rb
 - lib/graphql/static_validation/rules/required_input_object_attributes_are_present.rb
 - lib/graphql/static_validation/rules/required_input_object_attributes_are_present_error.rb
-- lib/graphql/static_validation/rules/subscription_root_exists.rb
+- lib/graphql/static_validation/rules/subscription_root_exists_and_single_subscription_selection.rb
 - lib/graphql/static_validation/rules/subscription_root_exists_error.rb
 - lib/graphql/static_validation/rules/unique_directives_per_location.rb
 - lib/graphql/static_validation/rules/unique_directives_per_location_error.rb
@@ -708,6 +728,7 @@ files:
 - lib/graphql/tracing/detailed_trace/redis_backend.rb
 - lib/graphql/tracing/legacy_hooks_trace.rb
 - lib/graphql/tracing/legacy_trace.rb
+- lib/graphql/tracing/monitor_trace.rb
 - lib/graphql/tracing/new_relic_trace.rb
 - lib/graphql/tracing/new_relic_tracing.rb
 - lib/graphql/tracing/notifications_trace.rb