graphql 1.7.3 → 1.7.4

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

@@ -6,11 +6,22 @@ module GraphQL
         return if node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
         arg_defn = defn.arguments[node.name]
         return unless arg_defn
-        if !context.valid_literal?(node.value, arg_defn.type)
+
+        begin
+          valid = context.valid_literal?(node.value, arg_defn.type)
+        rescue GraphQL::CoercionError => err
+          error_message = err.message
+        end
+
+        return if valid
+
+        error_message ||= begin
           kind_of_node = node_type(parent)
           error_arg_name = parent_name(parent, defn)
-          context.errors << message("Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value. Expected type '#{arg_defn.type}'.", parent, context: context)
+          "Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value. Expected type '#{arg_defn.type}'."
         end
+
+        context.errors << message(error_message, parent, context: context)
       end
     end
   end

data/lib/graphql/static_validation/validator.rb

@@ -22,7 +22,7 @@ module GraphQL
       # @param query [GraphQL::Query]
       # @return [Array<Hash>]
       def validate(query, validate: true)
-        GraphQL::Tracing.trace("validate", { validate: validate, query: query }) do
+        query.trace("validate", { validate: validate, query: query }) do
           context = GraphQL::StaticValidation::ValidationContext.new(query)
           rewrite = GraphQL::InternalRepresentation::Rewrite.new
 

data/lib/graphql/subscriptions.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require "graphql/subscriptions/event"
 require "graphql/subscriptions/instrumentation"
+require "graphql/subscriptions/serialize"
 if defined?(ActionCable)
   require "graphql/subscriptions/action_cable_subscriptions"
 end
@@ -24,7 +25,7 @@ module GraphQL
     # Fetch subscriptions matching this field + arguments pair
     # And pass them off to the queue.
     # @param event_name [String]
-    # @param args [Hash]
+    # @param args [Hash<String, Symbol => Object]
     # @param object [Object]
     # @param scope [Symbol, String]
     # @return [void]
@@ -34,6 +35,13 @@ module GraphQL
         raise "No subscription matching trigger: #{event_name}"
       end
 
+      # Normalize symbol-keyed args to strings
+      if args.any?
+        stringified_args = {}
+        args.each { |k, v| stringified_args[k.to_s] = v }
+        args = stringified_args
+      end
+
       event = Subscriptions::Event.new(
         name: event_name,
         arguments: args,

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -75,7 +75,9 @@ module GraphQL
       # Subscribers will re-evaluate locally.
       # TODO: this method name is a smell
       def execute_all(event, object)
-        ActionCable.server.broadcast(EVENT_PREFIX + event.topic, object)
+        stream = EVENT_PREFIX + event.topic
+        message = Serialize.dump(object)
+        ActionCable.server.broadcast(stream, message)
       end
 
       # This subscription was re-evaluated.
@@ -92,11 +94,12 @@ module GraphQL
       def write_subscription(query, events)
         channel = query.context[:channel]
         subscription_id = query.context[:subscription_id] ||= SecureRandom.uuid
-        channel.stream_from(SUBSCRIPTION_PREFIX + subscription_id)
+        stream = query.context[:action_cable_stream] ||= SUBSCRIPTION_PREFIX + subscription_id
+        channel.stream_from(stream)
         @subscriptions[subscription_id] = query
         events.each do |event|
           channel.stream_from(EVENT_PREFIX + event.topic, coder: ActiveSupport::JSON) do |message|
-            execute(subscription_id, event, message)
+            execute(subscription_id, event, Serialize.load(message))
             nil
           end
         end

data/lib/graphql/subscriptions/event.rb

@@ -46,7 +46,7 @@ module GraphQL
         end
 
         sorted_h = normalized_args.to_h.sort.to_h
-        JSON.dump([scope, name, sorted_h])
+        Serialize.dump_recursive([scope, name, sorted_h])
       end
     end
   end

data/lib/graphql/subscriptions/instrumentation.rb

@@ -56,7 +56,7 @@ module GraphQL
             ctx.skip
           elsif ctx.irep_node.subscription_topic == ctx.query.subscription_topic
             # The root object is _already_ the subscription update:
-            @inner_proc.call(obj, args, ctx)
+            obj
           else
             # This is a subscription update, but this event wasn't triggered.
             ctx.skip

data/lib/graphql/subscriptions/serialize.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+# test_via: ../subscriptions.rb
+module GraphQL
+  class Subscriptions
+    # Serialization helpers for passing subscription data around.
+    # @api private
+    module Serialize
+      GLOBALID_KEY = "__gid__"
+      module_function
+
+      # @param str [String] A serialized object from {.dump}
+      # @return [Object] An object equivalent to the one passed to {.dump}
+      def load(str)
+        parsed_obj = JSON.parse(str)
+        if parsed_obj.is_a?(Hash) && parsed_obj.size == 1 && parsed_obj.key?(GLOBALID_KEY)
+          GlobalID::Locator.locate(parsed_obj[GLOBALID_KEY])
+        else
+          parsed_obj
+        end
+      end
+
+      # @param obj [Object] Some subscription-related data to dump
+      # @return [String] The stringified object
+      def dump(obj)
+        if obj.respond_to?(:to_gid_param)
+          JSON.dump(GLOBALID_KEY => obj.to_gid_param)
+        else
+          JSON.generate(obj, quirks_mode: true)
+        end
+      end
+
+      # This is for turning objects into subscription scopes.
+      # It's a one-way transformation, can't reload this :'(
+      # @param obj [Object]
+      # @return [String]
+      def dump_recursive(obj)
+        case
+        when obj.is_a?(Array)
+          obj.map { |i| dump_recursive(i) }.join(':')
+        when obj.is_a?(Hash)
+          obj.map { |k, v| "#{dump_recursive(k)}:#{dump_recursive(v)}" }.join(":")
+        when obj.respond_to?(:to_gid_param)
+          obj.to_gid_param
+        when obj.respond_to?(:to_param)
+          obj.to_param
+        else
+          obj.to_s
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 require "graphql/tracing/active_support_notifications_tracing"
+require "graphql/tracing/platform_tracing"
+require "graphql/tracing/appsignal_tracing"
+require "graphql/tracing/new_relic_tracing"
+require "graphql/tracing/scout_tracing"
+require "graphql/tracing/skylight_tracing"
+
 module GraphQL
   # Library entry point for performance metric reporting.
   #
@@ -15,6 +21,14 @@ module GraphQL
   #     # do stuff ...
   #   end
   #
+  # @example Adding a tracer to a schema
+  #  MySchema = GraphQL::Schema.define do
+  #    tracer MyTracer # <= responds to .trace(key, data, &block)
+  #  end
+  #
+  # @example Adding a tracer to a query
+  #   MySchema.execute(query_str, context: { backtrace: true })
+  #
   # Events:
   #
   # Key | Metadata
@@ -24,15 +38,17 @@ module GraphQL
   # validate | `{ query: GraphQL::Query, validate: Boolean }`
   # analyze_multiplex |  `{ multiplex: GraphQL::Execution::Multiplex }`
   # analyze_query | `{ query: GraphQL::Query }`
-  # execute_multiplex | `{ query: GraphQL::Execution::Multiplex }`
+  # execute_multiplex | `{ multiplex: GraphQL::Execution::Multiplex }`
   # execute_query | `{ query: GraphQL::Query }`
-  # execute_query_lazy | `{ query: GraphQL::Query?, queries: Array<GraphQL::Query>? }`
+  # execute_query_lazy | `{ query: GraphQL::Query?, multiplex: GraphQL::Execution::Multiplex? }`
   # execute_field | `{ context: GraphQL::Query::Context::FieldResolutionContext }`
   # execute_field_lazy | `{ context: GraphQL::Query::Context::FieldResolutionContext }`
   #
   module Tracing
-    class << self
-      # Override this method to do stuff
+    # Objects may include traceable to gain a `.trace(...)` method.
+    # The object must have a `@tracers` ivar of type `Array<<#trace(k, d, &b)>>`.
+    # @api private
+    module Traceable
       # @param key [String] The name of the event in GraphQL internals
       # @param metadata [Hash] Event-related metadata (can be anything)
       # @return [Object] Must return the value of the block
@@ -40,23 +56,6 @@ module GraphQL
         call_tracers(0, key, metadata) { yield }
       end
 
-      # Install a tracer to receive events.
-      # @param tracer [<#trace(key, metadata)>]
-      # @return [void]
-      def install(tracer)
-        if !tracers.include?(tracer)
-          @tracers << tracer
-        end
-      end
-
-      def uninstall(tracer)
-        @tracers.delete(tracer)
-      end
-
-      def tracers
-        @tracers ||= []
-      end
-
       private
 
       # If there's a tracer at `idx`, call it and then increment `idx`.
@@ -74,7 +73,37 @@ module GraphQL
         end
       end
     end
+
+    class << self
+      # Install a tracer to receive events.
+      # @param tracer [<#trace(key, metadata)>]
+      # @return [void]
+      # @deprecated See {Schema#tracer} or use `context: { tracers: [...] }`
+      def install(tracer)
+        warn("GraphQL::Tracing.install is deprecated, add it to the schema with `tracer(my_tracer)` instead.")
+        if !tracers.include?(tracer)
+          @tracers << tracer
+        end
+      end
+
+      # @deprecated See {Schema#tracer} or use `context: { tracers: [...] }`
+      def uninstall(tracer)
+        @tracers.delete(tracer)
+      end
+
+      # @deprecated See {Schema#tracer} or use `context: { tracers: [...] }`
+      def tracers
+        @tracers ||= []
+      end
+    end
     # Initialize the array
     tracers
+
+    module NullTracer
+      module_function
+      def trace(k, v)
+        yield
+      end
+    end
   end
 end

data/lib/graphql/tracing/appsignal_tracing.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class AppsignalTracing < PlatformTracing
+      self.platform_keys = {
+        "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",
+      }
+
+      def platform_trace(platform_key, key, data)
+        Appsignal.instrument(platform_key) do
+          yield
+        end
+      end
+
+      def platform_field_key(type, field)
+        "#{type.name}.#{field.name}.graphql"
+      end
+    end
+  end
+end

data/lib/graphql/tracing/new_relic_tracing.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class NewRelicTracing < PlatformTracing
+      self.platform_keys = {
+        "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",
+      }
+
+      def platform_trace(platform_key, key, data)
+        NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped(platform_key) do
+          yield
+        end
+      end
+
+      def platform_field_key(type, field)
+        "GraphQL/#{type.name}/#{field.name}"
+      end
+    end
+  end
+end

data/lib/graphql/tracing/platform_tracing.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    # Each platform provides:
+    # - `.platform_keys`
+    # - `#platform_trace`
+    # - `#platform_field_key(type, field)`
+    # @api private
+    class PlatformTracing
+      class << self
+        attr_accessor :platform_keys
+      end
+
+      def initialize
+        @platform_keys = self.class.platform_keys
+      end
+
+      def trace(key, data)
+        case key
+        when "lex", "parse", "validate", "analyze_query", "analyze_multiplex", "execute_query", "execute_query_lazy", "execute_multiplex"
+          platform_key = @platform_keys.fetch(key)
+          platform_trace(platform_key, key, data) do
+            yield
+          end
+        when "execute_field", "execute_field_lazy"
+          if (platform_key = data[:context].field.metadata[:platform_key])
+            platform_trace(platform_key, key, data) do
+              yield
+            end
+          else
+            yield
+          end
+        else
+          # it's a custom key
+          yield
+        end
+      end
+
+      def instrument(type, field)
+        return_type = field.type.unwrap
+        case return_type
+        when GraphQL::ScalarType, GraphQL::EnumType
+          field
+        else
+          new_f = field.redefine
+          new_f.metadata[:platform_key] = platform_field_key(type, field)
+          new_f
+        end
+      end
+
+      def self.use(schema_defn)
+        tracer = self.new
+        schema_defn.instrument(:field, tracer)
+        schema_defn.tracer(tracer)
+      end
+    end
+  end
+end

data/lib/graphql/tracing/scout_tracing.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class ScoutTracing < PlatformTracing
+      if defined?(ScoutApm)
+        include ScoutApm::Tracer
+      end
+      INSTRUMENT_OPTS = { scope: true }
+
+      self.platform_keys = {
+        "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",
+      }
+
+      def platform_trace(platform_key, key, data)
+        self.class.instrument("GraphQL", platform_key, INSTRUMENT_OPTS) do
+          yield
+        end
+      end
+
+      def platform_field_key(type, field)
+        "#{type.name}.#{field.name}"
+      end
+    end
+  end
+end

data/lib/graphql/tracing/skylight_tracing.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class SkylightTracing < PlatformTracing
+      self.platform_keys = {
+        "lex" => "graphql.language",
+        "parse" => "graphql.language",
+        "validate" => "graphql.prepare",
+        "analyze_query" => "graphql.prepare",
+        "analyze_multiplex" => "graphql.prepare",
+        "execute_multiplex" => "graphql.execute",
+        "execute_query" => "graphql.execute",
+        "execute_query_lazy" => "graphql.execute",
+      }
+
+      def platform_trace(platform_key, key, data)
+        if (query = data[:query])
+          title = query.selected_operation_name || "<anonymous>"
+          category = platform_key
+        elsif key.start_with?("execute_field")
+          title = platform_key
+          category = key
+        else
+          title = key
+          category = platform_key
+        end
+
+        Skylight.instrument(category: category, title: title) do
+          yield
+        end
+      end
+
+      def platform_field_key(type, field)
+        "graphql.#{type.name}.#{field.name}"
+      end
+    end
+  end
+end