graphql 2.4.16 → 2.5.0

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.16"
+  VERSION = "2.5.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.4.16
+  version: 2.5.0
 platform: ruby
 authors:
 - Robert Mosolgo
@@ -676,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
@@ -686,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
@@ -727,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

data/lib/graphql/static_validation/rules/subscription_root_exists.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module StaticValidation
-    module SubscriptionRootExists
-      def on_operation_definition(node, _parent)
-        if node.operation_type == "subscription" && context.types.subscription_root.nil?
-          add_error(GraphQL::StaticValidation::SubscriptionRootExistsError.new(
-            'Schema is not configured for subscriptions',
-            nodes: node
-          ))
-        else
-          super
-        end
-      end
-    end
-  end
-end