graphql 1.13.17 → 2.0.20

data/lib/graphql/subscriptions.rb

@@ -5,7 +5,6 @@ require "graphql/subscriptions/event"
 require "graphql/subscriptions/instrumentation"
 require "graphql/subscriptions/serialize"
 require "graphql/subscriptions/action_cable_subscriptions"
-require "graphql/subscriptions/subscription_root"
 require "graphql/subscriptions/default_subscription_resolve_extension"
 
 module GraphQL
@@ -27,15 +26,12 @@ module GraphQL
     def self.use(defn, options = {})
       schema = defn.is_a?(Class) ? defn : defn.target
 
-      if schema.subscriptions
+      if schema.subscriptions(inherited: false)
         raise ArgumentError, "Can't reinstall subscriptions. #{schema} is using #{schema.subscriptions}, can't also add #{self}"
       end
 
       instrumentation = Subscriptions::Instrumentation.new(schema: schema)
       defn.instrument(:query, instrumentation)
-      if !schema.is_a?(Class)
-        defn.instrument(:field, instrumentation)
-      end
       options[:schema] = schema
       schema.subscriptions = self.new(**options)
       schema.add_subscription_extension_if_necessary
@@ -43,15 +39,14 @@ module GraphQL
     end
 
     # @param schema [Class] the GraphQL schema this manager belongs to
-    def initialize(schema:, broadcast: false, default_broadcastable: false, **rest)
+    # @param validate_update [Boolean] If false, then validation is skipped when executing updates
+    def initialize(schema:, validate_update: true, broadcast: false, default_broadcastable: false, **rest)
       if broadcast
-        if !schema.using_ast_analysis?
-          raise ArgumentError, "`broadcast: true` requires AST analysis, add `using GraphQL::Analysis::AST` to your schema or see https://graphql-ruby.org/queries/ast_analysis.html."
-        end
         schema.query_analyzer(Subscriptions::BroadcastAnalyzer)
       end
       @default_broadcastable = default_broadcastable
       @schema = schema
+      @validate_update = validate_update
     end
 
     # @return [Boolean] Used when fields don't have `broadcastable:` explicitly set
@@ -63,17 +58,21 @@ module GraphQL
     # @param args [Hash<String, Symbol => Object]
     # @param object [Object]
     # @param scope [Symbol, String]
+    # @param context [Hash]
     # @return [void]
-    def trigger(event_name, args, object, scope: nil)
+    def trigger(event_name, args, object, scope: nil, context: {})
+      # Make something as context-like as possible, even though there isn't a current query:
+      dummy_query = GraphQL::Query.new(@schema, "", validate: false, context: context)
+      context = dummy_query.context
       event_name = event_name.to_s
 
       # Try with the verbatim input first:
-      field = @schema.get_field(@schema.subscription, event_name)
+      field = @schema.get_field(@schema.subscription, event_name, context)
 
       if field.nil?
         # And if it wasn't found, normalize it:
         normalized_event_name = normalize_name(event_name)
-        field = @schema.get_field(@schema.subscription, normalized_event_name)
+        field = @schema.get_field(@schema.subscription, normalized_event_name, context)
         if field.nil?
           raise InvalidTriggerError, "No subscription matching trigger: #{event_name} (looked for #{@schema.subscription.graphql_name}.#{normalized_event_name})"
         end
@@ -91,6 +90,7 @@ module GraphQL
         arguments: normalized_args,
         field: field,
         scope: scope,
+        context: context,
       )
       execute_all(event, object)
     end
@@ -117,14 +117,20 @@ module GraphQL
       variables = query_data.fetch(:variables)
       context = query_data.fetch(:context)
       operation_name = query_data.fetch(:operation_name)
-      result = @schema.execute(
+      execute_options = {
         query: query_string,
         context: context,
         subscription_topic: event.topic,
         operation_name: operation_name,
         variables: variables,
         root_value: object,
-      )
+      }
+      
+       # merge event's and query's context together
+      context.merge!(event.context) unless event.context.nil? || context.nil?
+      
+      execute_options[:validate] = validate_update?(**execute_options)
+      result = @schema.execute(**execute_options)
       subscriptions_context = result.context.namespace(:subscriptions)
       if subscriptions_context[:no_update]
         result = nil
@@ -142,6 +148,14 @@ module GraphQL
       result
     end
 
+    # Define this method to customize whether to validate
+    # this subscription when executing an update.
+    #
+    # @return [Boolean] defaults to `true`, or false if `validate: false` is provided.
+    def validate_update?(query:, context:, root_value:, subscription_topic:, operation_name:, variables:)
+      @validate_update
+    end
+
     # Run the update query for this subscription and deliver it
     # @see {#execute_update}
     # @see {#deliver}
@@ -233,7 +247,7 @@ module GraphQL
     # @return [Any] normalized arguments value
     def normalize_arguments(event_name, arg_owner, args, context)
       case arg_owner
-      when GraphQL::Field, GraphQL::InputObjectType, GraphQL::Schema::Field, Class
+      when GraphQL::Schema::Field, Class
         if arg_owner.is_a?(Class) && !arg_owner.kind.input_object?
           # it's a type, but not an input object
           return args
@@ -274,9 +288,7 @@ module GraphQL
         end
 
         if missing_arg_names.any?
-          arg_owner_name = if arg_owner.is_a?(GraphQL::Field)
-            "Subscription.#{arg_owner.name}"
-          elsif arg_owner.is_a?(GraphQL::Schema::Field)
+          arg_owner_name = if arg_owner.is_a?(GraphQL::Schema::Field)
             arg_owner.path
           elsif arg_owner.is_a?(Class)
             arg_owner.graphql_name
@@ -287,9 +299,9 @@ module GraphQL
         end
 
         normalized_args
-      when GraphQL::ListType, GraphQL::Schema::List
+      when GraphQL::Schema::List
         args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a, context) }
-      when GraphQL::NonNullType, GraphQL::Schema::NonNull
+      when GraphQL::Schema::NonNull
         normalize_arguments(event_name, arg_owner.of_type, args, context)
       else
         args

data/lib/graphql/tracing/active_support_notifications_trace.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'graphql/tracing/notifications_trace'
+
+module GraphQL
+  module Tracing
+    # This implementation forwards events to ActiveSupport::Notifications
+    # with a `graphql` suffix.
+    module ActiveSupportNotificationsTrace
+      include NotificationsTrace
+      def initialize(engine: ActiveSupport::Notifications, **rest)
+        super
+      end
+    end
+  end
+end

data/lib/graphql/tracing/appoptics_trace.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+
+    # This class uses the AppopticsAPM SDK from the appoptics_apm gem to create
+    # traces for GraphQL.
+    #
+    # There are 4 configurations available. They can be set in the
+    # appoptics_apm config file or in code. Please see:
+    # {https://docs.appoptics.com/kb/apm_tracing/ruby/configure}
+    #
+    #     AppOpticsAPM::Config[:graphql][:enabled] = true|false
+    #     AppOpticsAPM::Config[:graphql][:transaction_name]  = true|false
+    #     AppOpticsAPM::Config[:graphql][:sanitize_query] = true|false
+    #     AppOpticsAPM::Config[:graphql][:remove_comments] = true|false
+    module AppOpticsTrace
+      # These GraphQL events will show up as 'graphql.prep' spans
+      PREP_KEYS = ['lex', 'parse', 'validate', 'analyze_query', 'analyze_multiplex'].freeze
+      # These GraphQL events will show up as 'graphql.execute' spans
+      EXEC_KEYS = ['execute_multiplex', 'execute_query', 'execute_query_lazy'].freeze
+
+      # During auto-instrumentation this version of AppOpticsTracing is compared
+      # with the version provided in the appoptics_apm gem, so that the newer
+      # version of the class can be used
+
+      def self.version
+        Gem::Version.new('1.0.0')
+      end
+
+      [
+        'lex',
+        'parse',
+        'validate',
+        'analyze_query',
+        'analyze_multiplex',
+        'execute_multiplex',
+        'execute_query',
+        'execute_query_lazy',
+      ].each do |trace_method|
+        module_eval <<-RUBY, __FILE__, __LINE__
+          def #{trace_method}(**data)
+            return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+            layer = span_name("#{trace_method}")
+            kvs = metadata(data, layer)
+            kvs[:Key] = "#{trace_method}" if (PREP_KEYS + EXEC_KEYS).include?("#{trace_method}")
+
+            transaction_name(kvs[:InboundQuery]) if kvs[:InboundQuery] && layer == 'graphql.execute'
+
+            ::AppOpticsAPM::SDK.trace(layer, kvs) do
+              kvs.clear # we don't have to send them twice
+              super
+            end
+          end
+        RUBY
+      end
+
+      def platform_execute_field(platform_key, data)
+        return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+        layer = platform_key
+        kvs = metadata(data, layer)
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          yield
+        end
+      end
+
+      def authorized(**data)
+        return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+        layer = @platform_authorized_key_cache[data[:type]]
+        kvs = metadata(data, layer)
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          super
+        end
+      end
+
+      def authorized_lazy(**data)
+        return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+        layer = @platform_authorized_key_cache[data[:type]]
+        kvs = metadata(data, layer)
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          super
+        end
+      end
+
+      def resolve_type(**data)
+        return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+        layer = @platform_resolve_type_key_cache[data[:type]]
+        kvs = metadata(data, layer)
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          super
+        end
+      end
+
+      def resolve_type_lazy(**data)
+        return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+        layer = @platform_resolve_type_key_cache[data[:type]]
+        kvs = metadata(data, layer)
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          super
+        end
+      end
+
+      include PlatformTrace
+
+      def platform_field_key(field)
+        "graphql.#{field.owner.graphql_name}.#{field.graphql_name}"
+      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 gql_config
+        ::AppOpticsAPM::Config[:graphql] ||= {}
+      end
+
+      def transaction_name(query)
+        return if gql_config[:transaction_name] == false ||
+          ::AppOpticsAPM::SDK.get_transaction_name
+
+        split_query = query.strip.split(/\W+/, 3)
+        split_query[0] = 'query' if split_query[0].empty?
+        name = "graphql.#{split_query[0..1].join('.')}"
+
+        ::AppOpticsAPM::SDK.set_transaction_name(name)
+      end
+
+      def multiplex_transaction_name(names)
+        return if gql_config[:transaction_name] == false ||
+          ::AppOpticsAPM::SDK.get_transaction_name
+
+        name = "graphql.multiplex.#{names.join('.')}"
+        name = "#{name[0..251]}..." if name.length > 254
+
+        ::AppOpticsAPM::SDK.set_transaction_name(name)
+      end
+
+      def span_name(key)
+        return 'graphql.prep' if PREP_KEYS.include?(key)
+        return 'graphql.execute' if EXEC_KEYS.include?(key)
+
+        key[/^graphql\./] ? key : "graphql.#{key}"
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def metadata(data, layer)
+        data.keys.map do |key|
+          case key
+          when :context
+            graphql_context(data[key], layer)
+          when :query
+            graphql_query(data[key])
+          when :query_string
+            graphql_query_string(data[key])
+          when :multiplex
+            graphql_multiplex(data[key])
+          when :path
+            [key, data[key].join(".")]
+          else
+            [key, data[key]]
+          end
+        end.flatten(2).each_slice(2).to_h.merge(Spec: 'graphql')
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def graphql_context(context, layer)
+        context.errors && context.errors.each do |err|
+          AppOpticsAPM::API.log_exception(layer, err)
+        end
+
+        [[:Path, context.path.join('.')]]
+      end
+
+      def graphql_query(query)
+        return [] unless query
+
+        query_string = query.query_string
+        query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
+        query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
+
+        [[:InboundQuery, query_string],
+         [:Operation, query.selected_operation_name]]
+      end
+
+      def graphql_query_string(query_string)
+        query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
+        query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
+
+        [:InboundQuery, query_string]
+      end
+
+      def graphql_multiplex(data)
+        names = data.queries.map(&:operations).map(&:keys).flatten.compact
+        multiplex_transaction_name(names) if names.size > 1
+
+        [:Operations, names.join(', ')]
+      end
+
+      def sanitize(query)
+        return unless query
+
+        # remove arguments
+        query.gsub(/"[^"]*"/, '"?"')                 # strings
+          .gsub(/-?[0-9]*\.?[0-9]+e?[0-9]*/, '?') # ints + floats
+          .gsub(/\[[^\]]*\]/, '[?]')              # arrays
+      end
+
+      def remove_comments(query)
+        return unless query
+
+        query.gsub(/#[^\n\r]*/, '')
+      end
+    end
+  end
+end

data/lib/graphql/tracing/appsignal_trace.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    module AppsignalTrace
+      include PlatformTrace
+
+      # @param set_action_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_appsignal_action_name]`.
+      def initialize(set_action_name: false, **rest)
+        @set_action_name = set_action_name
+        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, 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_appsignal_action_name]
+                if set_this_txn_name == true || (set_this_txn_name.nil? && @set_action_name)
+                  Appsignal::Transaction.current.set_action(transaction_name(data[:query]))
+                end
+                RUBY
+              end
+            }
+
+            Appsignal.instrument("#{platform_key}") do
+              super
+            end
+          end
+        RUBY
+      end
+
+      def platform_execute_field(platform_key)
+        Appsignal.instrument(platform_key) do
+          yield
+        end
+      end
+
+      def platform_authorized(platform_key)
+        Appsignal.instrument(platform_key) do
+          yield
+        end
+      end
+
+      def platform_field_key(field)
+        "#{field.owner.graphql_name}.#{field.graphql_name}.graphql"
+      end
+
+      def platform_authorized_key(type)
+        "#{type.graphql_name}.authorized.graphql"
+      end
+
+      def platform_resolve_type_key(type)
+        "#{type.graphql_name}.resolve_type.graphql"
+      end
+    end
+  end
+end

data/lib/graphql/tracing/data_dog_trace.rb

@@ -0,0 +1,148 @@
+# 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
+        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
+              }
+              prepare_span("#{trace_method.sub("platform_", "")}", data, span)
+              super
+            end
+          end
+        RUBY
+      end
+
+      def platform_execute_field(platform_key, data, span_key = "execute_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
+          prepare_span(span_key, data, span)
+          yield
+        end
+      end
+
+      def platform_execute_field_lazy(platform_key, data, &block)
+        platform_execute_field(platform_key, data, "execute_field_lazy", &block)
+      end
+
+      def authorized(object:, type:, query:, span_key: "authorized")
+        platform_key = @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
+          prepare_span(span_key, {object: object, type: type, query: query}, span)
+          super(query: query, type: type, object: object)
+        end
+      end
+
+      def authorized_lazy(**kwargs, &block)
+        authorized(span_key: "authorized_lazy", **kwargs, &block)
+      end
+
+      def resolve_type(object:, type:, query:, span_key: "resolve_type")
+        platform_key = @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
+          prepare_span(span_key, {object: object, type: type, query: query}, span)
+          super(query: query, type: type, object: object)
+        end
+      end
+
+      def resolve_type_lazy(**kwargs, &block)
+        resolve_type(span_key: "resolve_type_lazy", **kwargs, &block)
+      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

@@ -75,10 +75,12 @@ module GraphQL
       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