graphql 1.10.1 → 1.13.0

data/lib/graphql/subscriptions.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 require "securerandom"
+require "graphql/subscriptions/broadcast_analyzer"
 require "graphql/subscriptions/event"
 require "graphql/subscriptions/instrumentation"
 require "graphql/subscriptions/serialize"
-if defined?(ActionCable)
-  require "graphql/subscriptions/action_cable_subscriptions"
-end
+require "graphql/subscriptions/action_cable_subscriptions"
 require "graphql/subscriptions/subscription_root"
+require "graphql/subscriptions/default_subscription_resolve_extension"
 
 module GraphQL
   class Subscriptions
@@ -16,6 +16,13 @@ module GraphQL
     class InvalidTriggerError < GraphQL::Error
     end
 
+    # Raised when either:
+    # - An initial subscription didn't have a value for `context[subscription_scope]`
+    # - Or, an update didn't pass `.trigger(..., scope:)`
+    # When raised, the initial subscription or update fails completely.
+    class SubscriptionScopeMissingError < GraphQL::Error
+    end
+
     # @see {Subscriptions#initialize} for options, concrete implementations may add options.
     def self.use(defn, options = {})
       schema = defn.is_a?(Class) ? defn : defn.target
@@ -26,17 +33,30 @@ module GraphQL
 
       instrumentation = Subscriptions::Instrumentation.new(schema: schema)
       defn.instrument(:query, instrumentation)
-      defn.instrument(:field, 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
       nil
     end
 
     # @param schema [Class] the GraphQL schema this manager belongs to
-    def initialize(schema:, **rest)
+    def initialize(schema:, 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
     end
 
+    # @return [Boolean] Used when fields don't have `broadcastable:` explicitly set
+    attr_reader :default_broadcastable
+
     # Fetch subscriptions matching this field + arguments pair
     # And pass them off to the queue.
     # @param event_name [String]
@@ -63,7 +83,8 @@ module GraphQL
       end
 
       # Normalize symbol-keyed args to strings, try camelizing them
-      normalized_args = normalize_arguments(normalized_event_name, field, args)
+      # Should this accept a real context somehow?
+      normalized_args = normalize_arguments(normalized_event_name, field, args, GraphQL::Query::NullContext)
 
       event = Subscriptions::Event.new(
         name: normalized_event_name,
@@ -77,40 +98,59 @@ module GraphQL
     # `event` was triggered on `object`, and `subscription_id` was subscribed,
     # so it should be updated.
     #
-    # Load `subscription_id`'s GraphQL data, re-evaluate the query, and deliver the result.
-    #
-    # This is where a queue may be inserted to push updates in the background.
+    # Load `subscription_id`'s GraphQL data, re-evaluate the query and return the result.
     #
     # @param subscription_id [String]
     # @param event [GraphQL::Subscriptions::Event] The event which was triggered
     # @param object [Object] The value for the subscription field
-    # @return [void]
-    def execute(subscription_id, event, object)
+    # @return [GraphQL::Query::Result]
+    def execute_update(subscription_id, event, object)
       # Lookup the saved data for this subscription
       query_data = read_subscription(subscription_id)
+      if query_data.nil?
+        delete_subscription(subscription_id)
+        return nil
+      end
+
       # Fetch the required keys from the saved data
       query_string = query_data.fetch(:query_string)
       variables = query_data.fetch(:variables)
       context = query_data.fetch(:context)
       operation_name = query_data.fetch(:operation_name)
-      # Re-evaluate the saved query
       result = @schema.execute(
-        **{
-          query: query_string,
-          context: context,
-          subscription_topic: event.topic,
-          operation_name: operation_name,
-          variables: variables,
-          root_value: object,
-        }
+        query: query_string,
+        context: context,
+        subscription_topic: event.topic,
+        operation_name: operation_name,
+        variables: variables,
+        root_value: object,
       )
-      deliver(subscription_id, result)
-    rescue GraphQL::Schema::Subscription::NoUpdateError
-      # This update was skipped in user code; do nothing.
-    rescue GraphQL::Schema::Subscription::UnsubscribedError
-      # `unsubscribe` was called, clean up on our side
-      # TODO also send `{more: false}` to client?
-      delete_subscription(subscription_id)
+      subscriptions_context = result.context.namespace(:subscriptions)
+      if subscriptions_context[:no_update]
+        result = nil
+      end
+
+      unsubscribed = subscriptions_context[:unsubscribed]
+
+      if unsubscribed
+        # `unsubscribe` was called, clean up on our side
+        # TODO also send `{more: false}` to client?
+        delete_subscription(subscription_id)
+        result = nil
+      end
+
+      result
+    end
+
+    # Run the update query for this subscription and deliver it
+    # @see {#execute_update}
+    # @see {#deliver}
+    # @return [void]
+    def execute(subscription_id, event, object)
+      res = execute_update(subscription_id, event, object)
+      if !res.nil?
+        deliver(subscription_id, res)
+      end
     end
 
     # Event `event` occurred on `object`,
@@ -119,16 +159,6 @@ module GraphQL
     # @param object [Object]
     # @return [void]
     def execute_all(event, object)
-      each_subscription_id(event) do |subscription_id|
-        execute(subscription_id, event, object)
-      end
-    end
-
-    # Get each `subscription_id` subscribed to `event.topic` and yield them
-    # @param event [GraphQL::Subscriptions::Event]
-    # @yieldparam subscription_id [String]
-    # @return [void]
-    def each_subscription_id(event)
       raise GraphQL::RequiredImplementationMissingError
     end
 
@@ -183,6 +213,16 @@ module GraphQL
       Schema::Member::BuildType.camelize(event_or_arg_name.to_s)
     end
 
+    # @return [Boolean] if true, then a query like this one would be broadcasted
+    def broadcastable?(query_str, **query_options)
+      query = GraphQL::Query.new(@schema, query_str, **query_options)
+      if !query.valid?
+        raise "Invalid query: #{query.validation_errors.map(&:to_h).inspect}"
+      end
+      GraphQL::Analysis::AST.analyze_query(query, @schema.query_analyzers)
+      query.context.namespace(:subscriptions)[:subscription_broadcastable]
+    end
+
     private
 
     # Recursively normalize `args` as belonging to `arg_owner`:
@@ -191,7 +231,7 @@ module GraphQL
     # @param arg_owner [GraphQL::Field, GraphQL::BaseType]
     # @param args [Hash, Array, Any] some GraphQL input value to coerce as `arg_owner`
     # @return [Any] normalized arguments value
-    def normalize_arguments(event_name, arg_owner, args)
+    def normalize_arguments(event_name, arg_owner, args, context)
       case arg_owner
       when GraphQL::Field, GraphQL::InputObjectType, GraphQL::Schema::Field, Class
         if arg_owner.is_a?(Class) && !arg_owner.kind.input_object?
@@ -202,19 +242,19 @@ module GraphQL
         missing_arg_names = []
         args.each do |k, v|
           arg_name = k.to_s
-          arg_defn = arg_owner.arguments[arg_name]
+          arg_defn = arg_owner.get_argument(arg_name, context)
           if arg_defn
             normalized_arg_name = arg_name
           else
             normalized_arg_name = normalize_name(arg_name)
-            arg_defn = arg_owner.arguments[normalized_arg_name]
+            arg_defn = arg_owner.get_argument(normalized_arg_name, context)
           end
 
           if arg_defn
             if arg_defn.loads
               normalized_arg_name = arg_defn.keyword.to_s
             end
-            normalized = normalize_arguments(event_name, arg_defn.type, v)
+            normalized = normalize_arguments(event_name, arg_defn.type, v, context)
             normalized_args[normalized_arg_name] = normalized
           else
             # Couldn't find a matching argument definition
@@ -224,9 +264,12 @@ module GraphQL
 
         # Backfill default values so that trigger arguments
         # match query arguments.
-        arg_owner.arguments.each do |name, arg_defn|
+        arg_owner.arguments(context).each do |_name, arg_defn|
           if arg_defn.default_value? && !normalized_args.key?(arg_defn.name)
-            normalized_args[arg_defn.name] = arg_defn.default_value
+            default_value = arg_defn.default_value
+            # We don't have an underlying "object" here, so it can't call methods.
+            # This is broken.
+            normalized_args[arg_defn.name] = arg_defn.prepare_value(nil, default_value, context: context)
           end
         end
 
@@ -245,9 +288,9 @@ module GraphQL
 
         normalized_args
       when GraphQL::ListType, GraphQL::Schema::List
-        args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a) }
+        args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a, context) }
       when GraphQL::NonNullType, GraphQL::Schema::NonNull
-        normalize_arguments(event_name, arg_owner.of_type, args)
+        normalize_arguments(event_name, arg_owner.of_type, args, context)
       else
         args
       end

data/lib/graphql/tracing/active_support_notifications_tracing.rb

@@ -3,8 +3,9 @@
 module GraphQL
   module Tracing
     # This implementation forwards events to ActiveSupport::Notifications
-    # with a `graphql.` prefix.
+    # with a `graphql` suffix.
     #
+    # @see KEYS for event names
     module ActiveSupportNotificationsTracing
       # A cache of frequently-used keys to avoid needless string allocations
       KEYS = {

data/lib/graphql/tracing/appoptics_tracing.rb

@@ -0,0 +1,173 @@
+# 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
+    class AppOpticsTracing < GraphQL::Tracing::PlatformTracing
+      # 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
+
+      self.platform_keys = {
+        'lex' => 'lex',
+        'parse' => 'parse',
+        'validate' => 'validate',
+        'analyze_query' => 'analyze_query',
+        'analyze_multiplex' => 'analyze_multiplex',
+        'execute_multiplex' => 'execute_multiplex',
+        'execute_query' => 'execute_query',
+        'execute_query_lazy' => 'execute_query_lazy'
+      }
+
+      def platform_trace(platform_key, _key, data)
+        return yield if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+
+        layer = span_name(platform_key)
+        kvs = metadata(data, layer)
+        kvs[:Key] = platform_key if (PREP_KEYS + EXEC_KEYS).include?(platform_key)
+
+        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
+          yield
+        end
+      end
+
+      def platform_field_key(type, field)
+        "graphql.#{type.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_tracing.rb

@@ -14,7 +14,22 @@ module GraphQL
         "execute_query_lazy" => "execute.graphql",
       }
 
+      # @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(options = {})
+        @set_action_name = options.fetch(:set_action_name, false)
+        super
+      end
+
       def platform_trace(platform_key, key, data)
+        if key == "execute_query"
+          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
+        end
+
         Appsignal.instrument(platform_key) do
           yield
         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
 

data/lib/graphql/tracing/platform_tracing.rb

@@ -32,17 +32,19 @@ module GraphQL
             trace_field = true # implemented with instrumenter
           else
             field = data[:field]
-            cache = platform_key_cache(data.fetch(:query).context)
-            platform_key = cache.fetch(field) do
-              cache[field] = platform_field_key(data[:owner], field)
-            end
-
             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
+              context = data.fetch(:query).context
+              cached_platform_key(context, field) { platform_field_key(data[:owner], field) }
+            else
+              nil
+            end
           end
 
           if platform_key && trace_field
@@ -53,20 +55,16 @@ module GraphQL
             yield
           end
         when "authorized", "authorized_lazy"
-          cache = platform_key_cache(data.fetch(:context))
           type = data.fetch(:type)
-          platform_key = cache.fetch(type) do
-            cache[type] = platform_authorized_key(type)
-          end
+          context = data.fetch(:context)
+          platform_key = cached_platform_key(context, type) { platform_authorized_key(type) }
           platform_trace(platform_key, key, data) do
             yield
           end
         when "resolve_type", "resolve_type_lazy"
-          cache = platform_key_cache(data.fetch(:context))
           type = data.fetch(:type)
-          platform_key = cache.fetch(type) do
-            cache[type] = platform_resolve_type_key(type)
-          end
+          context = data.fetch(:context)
+          platform_key = cached_platform_key(context, type) { platform_resolve_type_key(type) }
           platform_trace(platform_key, key, data) do
             yield
           end
@@ -97,16 +95,44 @@ module GraphQL
       end
 
       def self.use(schema_defn, options = {})
-        tracer = self.new(options)
-        schema_defn.instrument(:field, tracer)
+        tracer = self.new(**options)
+        if !schema_defn.is_a?(Class)
+          schema_defn.instrument(:field, tracer)
+        end
         schema_defn.tracer(tracer)
       end
 
       private
+
+      # Get the transaction name based on the operation type and name
+      def transaction_name(query)
+        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
+        "GraphQL/#{op_type}.#{op_name}"
+      end
+
       attr_reader :options
 
-      def platform_key_cache(ctx)
-        ctx.namespace(self.class)[:platform_key_cache] ||= {}
+      # Different kind of schema objects have different kinds of keys:
+      #
+      # - Object types: `.authorized`
+      # - Union/Interface types: `.resolve_type`
+      # - Fields: execution
+      #
+      # So, they can all share one cache.
+      #
+      # If the key isn't present, the given block is called and the result is cached for `key`.
+      #
+      # @return [String]
+      def cached_platform_key(ctx, key)
+        cache = ctx.namespace(self.class)[:platform_key_cache] ||= {}
+        cache.fetch(key) { cache[key] = yield }
       end
     end
   end

data/lib/graphql/tracing/prometheus_tracing/graphql_collector.rb

@@ -16,7 +16,10 @@ module GraphQL
         end
 
         def collect(object)
-          labels = { key: object['key'], platform_key: object['platform_key'] }
+          default_labels = { key: object['key'], platform_key: object['platform_key'] }
+          custom = object['custom_labels']
+          labels = custom.nil? ? default_labels : default_labels.merge(custom)
+
           @graphql_gauge.observe object['duration'], labels
         end
 

data/lib/graphql/tracing/scout_tracing.rb

@@ -16,12 +16,23 @@ module GraphQL
         "execute_query_lazy" => "execute.graphql",
       }
 
+      # @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(options = {})
         self.class.include ScoutApm::Tracer
+        @set_transaction_name = options.fetch(:set_transaction_name, false)
         super(options)
       end
 
       def platform_trace(platform_key, key, data)
+        if key == "execute_query"
+          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
+        end
+
         self.class.instrument("GraphQL", platform_key, INSTRUMENT_OPTS) do
           yield
         end

data/lib/graphql/tracing/skylight_tracing.rb

@@ -18,7 +18,7 @@ module GraphQL
       #   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_skylight_endpoint_name]`.
       def initialize(options = {})
-        warn("GraphQL::Tracing::SkylightTracing is deprecated, please enable Skylight's GraphQL probe instead: https://www.skylight.io/support/getting-more-from-skylight#graphql.")
+        GraphQL::Deprecation.warn("GraphQL::Tracing::SkylightTracing is deprecated and will be removed in GraphQL-Ruby 2.0, please enable Skylight's GraphQL probe instead: https://www.skylight.io/support/getting-more-from-skylight#graphql.")
         @set_endpoint_name = options.fetch(:set_endpoint_name, false)
         super
       end

data/lib/graphql/tracing/statsd_tracing.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class StatsdTracing < PlatformTracing
+      self.platform_keys = {
+        '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",
+      }
+
+      # @param statsd [Object] A statsd client
+      def initialize(statsd:, **rest)
+        @statsd = statsd
+        super(**rest)
+      end
+
+      def platform_trace(platform_key, key, data)
+        @statsd.time(platform_key) do
+          yield
+        end
+      end
+
+      def platform_field_key(type, field)
+        "graphql.#{type.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
+    end
+  end
+end