graphql 2.4.3 → 2.4.13

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

@@ -24,7 +24,7 @@ module GraphQL
           .map!(&:name)
 
         missing_names = required_argument_names - present_argument_names
-        if missing_names.any?
+        if !missing_names.empty?
           add_error(GraphQL::StaticValidation::RequiredArgumentsArePresentError.new(
             "#{ast_node.class.name.split("::").last} '#{ast_node.name}' is missing required arguments: #{missing_names.join(", ")}",
             nodes: ast_node,

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

@@ -21,7 +21,7 @@ module GraphQL
 
       DIRECTIVE_NODE_HOOKS.each do |method_name|
         define_method(method_name) do |node, parent|
-          if node.directives.any?
+          if !node.directives.empty?
             validate_directive_location(node)
           end
           super(node, parent)

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

@@ -4,7 +4,7 @@ module GraphQL
     module VariableNamesAreUnique
       def on_operation_definition(node, parent)
         var_defns = node.variables
-        if var_defns.any?
+        if !var_defns.empty?
           vars_by_name = Hash.new { |h, k| h[k] = [] }
           var_defns.each { |v| vars_by_name[v.name] << v }
           vars_by_name.each do |name, defns|

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

@@ -21,7 +21,7 @@ module GraphQL
         end
         node_values = node_values.select { |value| value.is_a? GraphQL::Language::Nodes::VariableIdentifier }
 
-        if node_values.any?
+        if !node_values.empty?
           argument_owner = case parent
           when GraphQL::Language::Nodes::Field
             context.field_definition

data/lib/graphql/static_validation/validation_context.rb

@@ -29,6 +29,7 @@ module GraphQL
         @visitor = visitor_class.new(document, self)
       end
 
+      # TODO stop using def_delegators because of Array allocations
       def_delegators :@visitor,
         :path, :type_definition, :field_definition, :argument_definition,
         :parent_type_definition, :directive_definition, :object_types, :dependencies

data/lib/graphql/static_validation/validator.rb

@@ -27,6 +27,8 @@ module GraphQL
       # @param max_errors [Integer] Maximum number of errors before aborting validation. Any positive number will limit the number of errors. Defaults to nil for no limit.
       # @return [Array<Hash>]
       def validate(query, validate: true, timeout: nil, max_errors: nil)
+        errors = nil
+        query.current_trace.begin_validate(query, validate)
         query.current_trace.validate(validate: validate, query: query) do
           begin_t = Time.now
           errors = if validate == false
@@ -58,10 +60,13 @@ module GraphQL
           }
         end
       rescue GraphQL::ExecutionError => e
+        errors = [e]
         {
           remaining_timeout: nil,
-          errors: [e],
+          errors: errors,
         }
+      ensure
+        query.current_trace.end_validate(query, validate, errors)
       end
 
       # Invoked when static validation times out.

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -171,7 +171,7 @@ module GraphQL
           events_by_fingerprint = @events[topic]
           object = nil
           events_by_fingerprint.each do |_fingerprint, events|
-            if events.any? && events.first == initial_event
+            if !events.empty? && events.first == initial_event
               # The fingerprint has told us that this response should be shared by all subscribers,
               # so just run it once, then deliver the result to every subscriber
               first_event = events.first

data/lib/graphql/subscriptions/default_subscription_resolve_extension.rb

@@ -20,12 +20,22 @@ module GraphQL
       def after_resolve(value:, context:, object:, arguments:, **rest)
         if value.is_a?(GraphQL::ExecutionError)
           value
+        elsif @field.resolver&.method_defined?(:subscription_written?) &&
+          (subscription_namespace = context.namespace(:subscriptions)) &&
+          (subscriptions_by_path = subscription_namespace[:subscriptions])
+          (subscription_instance = subscriptions_by_path[context.current_path])
+          # If it was already written, don't append this event to be written later
+          if !subscription_instance.subscription_written?
+            events = context.namespace(:subscriptions)[:events]
+            events << subscription_instance.event
+          end
+          value
         elsif (events = context.namespace(:subscriptions)[:events])
           # This is the first execution, so gather an Event
           # for the backend to register:
           event = Subscriptions::Event.new(
             name: field.name,
-            arguments: arguments_without_field_extras(arguments: arguments),
+            arguments: arguments,
             context: context,
             field: field,
           )
@@ -33,7 +43,7 @@ module GraphQL
           value
         elsif context.query.subscription_topic == Subscriptions::Event.serialize(
             field.name,
-            arguments_without_field_extras(arguments: arguments),
+            arguments,
             field,
             scope: (field.subscription_scope ? context[field.subscription_scope] : nil),
           )
@@ -45,14 +55,6 @@ module GraphQL
           context.skip
         end
       end
-
-      private
-
-      def arguments_without_field_extras(arguments:)
-        arguments.dup.tap do |event_args|
-          field.extras.each { |k| event_args.delete(k) }
-        end
-      end
     end
   end
 end

data/lib/graphql/subscriptions/event.rb

@@ -20,7 +20,7 @@ module GraphQL
 
       def initialize(name:, arguments:, field: nil, context: nil, scope: nil)
         @name = name
-        @arguments = arguments
+        @arguments = self.class.arguments_without_field_extras(arguments: arguments, field: field)
         @context = context
         field ||= context.field
         scope_key = field.subscription_scope
@@ -39,6 +39,7 @@ module GraphQL
       # @return [String] an identifier for this unit of subscription
       def self.serialize(_name, arguments, field, scope:, context: GraphQL::Query::NullContext.instance)
         subscription = field.resolver || GraphQL::Schema::Subscription
+        arguments = arguments_without_field_extras(field: field, arguments: arguments)
         normalized_args = stringify_args(field, arguments.to_h, context)
         subscription.topic_for(arguments: normalized_args, field: field, scope: scope)
       end
@@ -60,6 +61,16 @@ module GraphQL
       end
 
       class << self
+        def arguments_without_field_extras(arguments:, field:)
+          if !field.extras.empty?
+            arguments = arguments.dup
+            field.extras.each do |extra_key|
+              arguments.delete(extra_key)
+            end
+          end
+          arguments
+        end
+
         private
 
         # This method does not support cyclic references in the Hash,

data/lib/graphql/subscriptions/serialize.rb

@@ -146,7 +146,7 @@ module GraphQL
           elsif obj.is_a?(Date) || obj.is_a?(Time)
             # DateTime extends Date; for TimeWithZone, call `.utc` first.
             { TIMESTAMP_KEY => [obj.class.name, obj.strftime(TIMESTAMP_FORMAT)] }
-          elsif obj.is_a?(OpenStruct)
+          elsif defined?(OpenStruct) && obj.is_a?(OpenStruct)
             { OPEN_STRUCT_KEY => dump_value(obj.to_h) }
           elsif defined?(ActiveRecord::Relation) && obj.is_a?(ActiveRecord::Relation)
             dump_value(obj.to_a)

data/lib/graphql/subscriptions.rb

@@ -291,7 +291,7 @@ module GraphQL
           end
         end
 
-        if missing_arg_names.any?
+        if !missing_arg_names.empty?
           arg_owner_name = if arg_owner.is_a?(GraphQL::Schema::Field)
             arg_owner.path
           elsif arg_owner.is_a?(Class)

data/lib/graphql/testing/helpers.rb

@@ -58,7 +58,7 @@ module GraphQL
                 query_context[:current_field] = visible_field
                 field_args = visible_field.coerce_arguments(graphql_result, arguments, query_context)
                 field_args = schema.sync_lazy(field_args)
-                if visible_field.extras.any?
+                if !visible_field.extras.empty?
                   extra_args = {}
                   visible_field.extras.each do |extra|
                     extra_args[extra] = case extra
@@ -92,7 +92,7 @@ module GraphQL
           end
           graphql_result
         else
-          unfiltered_type = Schema::Visibility::Profile.null_profile(schema: schema, context: context).type(type_name)
+          unfiltered_type = schema.use_visibility_profile? ? schema.visibility.get_type(type_name) : schema.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
           if unfiltered_type
             raise TypeNotVisibleError.new(type_name: type_name)
           else

data/lib/graphql/tracing/active_support_notifications_trace.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
-require 'graphql/tracing/notifications_trace'
+require "graphql/tracing/notifications_trace"
 
 module GraphQL
   module Tracing
-    # This implementation forwards events to ActiveSupport::Notifications
-    # with a `graphql` suffix.
+    # This implementation forwards events to ActiveSupport::Notifications with a `graphql` suffix.
+    #
+    # @example Sending execution events to ActiveSupport::Notifications
+    #   class MySchema < GraphQL::Schema
+    #     trace_with(GraphQL::Tracing::ActiveSupportNotificationsTrace)
+    #   end
     module ActiveSupportNotificationsTrace
       include NotificationsTrace
       def initialize(engine: ActiveSupport::Notifications, **rest)

data/lib/graphql/tracing/active_support_notifications_tracing.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'graphql/tracing/notifications_tracing'
+require "graphql/tracing/notifications_tracing"
 
 module GraphQL
   module Tracing

data/lib/graphql/tracing/appoptics_trace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_trace"
+
 module GraphQL
   module Tracing
 
@@ -20,14 +22,18 @@ module GraphQL
       # 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
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       [
         'lex',
         'parse',
@@ -55,6 +61,8 @@ module GraphQL
         RUBY
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       def execute_field(query:, field:, ast_node:, arguments:, object:)
         return_type = field.type.unwrap
         trace_field = if return_type.kind.scalar? || return_type.kind.enum?
@@ -81,7 +89,7 @@ module GraphQL
         end
       end
 
-      def execute_field_lazy(query:, field:, ast_node:, arguments:, object:)
+      def execute_field_lazy(query:, field:, ast_node:, arguments:, object:)  # rubocop:disable Development/TraceCallsSuperCop
         execute_field(query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
       end
 

data/lib/graphql/tracing/appoptics_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
 

data/lib/graphql/tracing/appsignal_trace.rb

@@ -1,7 +1,15 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_trace"
+
 module GraphQL
   module Tracing
+    # Instrumentation for reporting GraphQL-Ruby times to Appsignal.
+    #
+    # @example Installing the tracer
+    #   class MySchema < GraphQL::Schema
+    #     trace_with GraphQL::Tracing::AppsignalTrace
+    #   end
     module AppsignalTrace
       include PlatformTrace
 
@@ -13,6 +21,8 @@ module GraphQL
         super
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       {
         "lex" => "lex.graphql",
         "parse" => "parse.graphql",
@@ -43,6 +53,8 @@ module GraphQL
         RUBY
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       def platform_execute_field(platform_key)
         Appsignal.instrument(platform_key) do
           yield

data/lib/graphql/tracing/appsignal_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
     class AppsignalTracing < PlatformTracing

data/lib/graphql/tracing/call_legacy_tracers.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    # This trace class calls legacy-style tracer with payload hashes.
+    # New-style `trace_with` modules significantly reduce the overhead of tracing,
+    # but that advantage is lost when legacy-style tracers are also used (since the payload hashes are still constructed).
+    module CallLegacyTracers
+      def lex(query_string:)
+        (@multiplex || @query).trace("lex", { query_string: query_string }) { super }
+      end
+
+      def parse(query_string:)
+        (@multiplex || @query).trace("parse", { query_string: query_string }) { super }
+      end
+
+      def validate(query:, validate:)
+        query.trace("validate", { validate: validate, query: query }) { super }
+      end
+
+      def analyze_multiplex(multiplex:)
+        multiplex.trace("analyze_multiplex", { multiplex: multiplex }) { super }
+      end
+
+      def analyze_query(query:)
+        query.trace("analyze_query", { query: query }) { super }
+      end
+
+      def execute_multiplex(multiplex:)
+        multiplex.trace("execute_multiplex", { multiplex: multiplex }) { super }
+      end
+
+      def execute_query(query:)
+        query.trace("execute_query", { query: query }) { super }
+      end
+
+      def execute_query_lazy(query:, multiplex:)
+        multiplex.trace("execute_query_lazy", { multiplex: multiplex, query: query }) { super }
+      end
+
+      def execute_field(field:, query:, ast_node:, arguments:, object:)
+        query.trace("execute_field", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
+        query.trace("execute_field_lazy", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
+      end
+
+      def authorized(query:, type:, object:)
+        query.trace("authorized", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def authorized_lazy(query:, type:, object:)
+        query.trace("authorized_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def resolve_type(query:, type:, object:)
+        query.trace("resolve_type", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def resolve_type_lazy(query:, type:, object:)
+        query.trace("resolve_type_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+    end
+  end
+end

data/lib/graphql/tracing/data_dog_trace.rb

@@ -1,7 +1,14 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_trace"
+
 module GraphQL
   module Tracing
+    # A tracer for reporting to DataDog
+    # @example Adding this tracer to your schema
+    #   class MySchema < GraphQL::Schema
+    #     trace_with GraphQL::Tracing::DataDogTrace
+    #   end
     module DataDogTrace
       # @param tracer [#trace] Deprecated
       # @param analytics_enabled [Boolean] Deprecated
@@ -20,6 +27,8 @@ module GraphQL
         super
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       {
         'lex' => 'lex.graphql',
         'parse' => 'parse.graphql',
@@ -69,6 +78,8 @@ module GraphQL
         RUBY
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       def execute_field_span(span_key, query, field, ast_node, arguments, object)
         return_type = field.type.unwrap
         trace_field = if return_type.kind.scalar? || return_type.kind.enum?

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
     class DataDogTracing < PlatformTracing

data/lib/graphql/tracing/detailed_trace/memory_backend.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class DetailedTrace
+      # An in-memory trace storage backend. Suitable for testing and development only.
+      # It won't work for multi-process deployments and everything is erased when the app is restarted.
+      class MemoryBackend
+        def initialize(limit: nil)
+          @limit = limit
+          @traces = {}
+          @next_id = 0
+        end
+
+        def traces(last:, before:)
+          page = []
+          @traces.values.reverse_each do |trace|
+            if page.size == last
+              break
+            elsif before.nil? || trace.begin_ms < before
+              page << trace
+            end
+          end
+          page
+        end
+
+        def find_trace(id)
+          @traces[id]
+        end
+
+        def delete_trace(id)
+          @traces.delete(id.to_i)
+          nil
+        end
+
+        def delete_all_traces
+          @traces.clear
+          nil
+        end
+
+        def save_trace(operation_name, duration, begin_ms, trace_data)
+          id = @next_id
+          @next_id += 1
+          @traces[id] = DetailedTrace::StoredTrace.new(
+            id: id,
+            operation_name: operation_name,
+            duration_ms: duration,
+            begin_ms: begin_ms,
+            trace_data: trace_data
+          )
+          if @limit && @traces.size > @limit
+            del_keys = @traces.keys[0...-@limit]
+            del_keys.each { |k| @traces.delete(k) }
+          end
+          id
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/detailed_trace/redis_backend.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class DetailedTrace
+      class RedisBackend
+        KEY_PREFIX = "gql:trace:"
+        def initialize(redis:, limit: nil)
+          @redis = redis
+          @key = KEY_PREFIX + "traces"
+          @remrangebyrank_limit = limit ? -limit - 1 : nil
+        end
+
+        def traces(last:, before:)
+          before = case before
+          when Numeric
+            "(#{before}"
+          when nil
+            "+inf"
+          end
+          str_pairs = @redis.zrange(@key, before, 0, byscore: true, rev: true, limit: [0, last || 100], withscores: true)
+          str_pairs.map do |(str_data, score)|
+            entry_to_trace(score, str_data)
+          end
+        end
+
+        def delete_trace(id)
+          @redis.zremrangebyscore(@key, id, id)
+          nil
+        end
+
+        def delete_all_traces
+          @redis.del(@key)
+        end
+
+        def find_trace(id)
+          str_data = @redis.zrange(@key, id, id, byscore: true).first
+          if str_data.nil?
+            nil
+          else
+            entry_to_trace(id, str_data)
+          end
+        end
+
+        def save_trace(operation_name, duration_ms, begin_ms, trace_data)
+          id = begin_ms
+          data = JSON.dump({ "o" => operation_name, "d" => duration_ms, "b" => begin_ms, "t" => Base64.encode64(trace_data) })
+          @redis.pipelined do |pipeline|
+            pipeline.zadd(@key, id, data)
+            if @remrangebyrank_limit
+              pipeline.zremrangebyrank(@key, 0, @remrangebyrank_limit)
+            end
+          end
+          id
+        end
+
+        private
+
+        def entry_to_trace(id, json_str)
+          data = JSON.parse(json_str)
+          StoredTrace.new(
+            id: id,
+            operation_name: data["o"],
+            duration_ms: data["d"].to_f,
+            begin_ms: data["b"].to_i,
+            trace_data: Base64.decode64(data["t"]),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/detailed_trace.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+require "graphql/tracing/detailed_trace/memory_backend"
+require "graphql/tracing/detailed_trace/redis_backend"
+
+module GraphQL
+  module Tracing
+    # `DetailedTrace` can make detailed profiles for a subset of production traffic.
+    #
+    # When `MySchema.detailed_trace?(query)` returns `true`, a profiler-specific `trace_mode: ...` will be used for the query,
+    # overriding the one in `context[:trace_mode]`.
+    #
+    # __Redis__: The sampler stores its results in a provided Redis database. Depending on your needs,
+    # You can configure this database to retail all data (persistent) or to expire data according to your rules.
+    # If you need to save traces indefinitely, you can download them from Perfetto after opening them there.
+    #
+    # @example Adding the sampler to your schema
+    #   class MySchema < GraphQL::Schema
+    #     # Add the sampler:
+    #     use GraphQL::Tracing::DetailedTrace, redis: Redis.new(...), limit: 100
+    #
+    #     # And implement this hook to tell it when to take a sample:
+    #     def self.detailed_trace?(query)
+    #       # Could use `query.context`, `query.selected_operation_name`, `query.query_string` here
+    #       # Could call out to Flipper, etc
+    #       rand <= 0.000_1 # one in ten thousand
+    #     end
+    #   end
+    #
+    # @see Graphql::Dashboard GraphQL::Dashboard for viewing stored results
+    class DetailedTrace
+      # @param redis [Redis] If provided, profiles will be stored in Redis for later review
+      # @param limit [Integer] A maximum number of profiles to store
+      def self.use(schema, trace_mode: :profile_sample, memory: false, redis: nil, limit: nil)
+        storage = if redis
+          RedisBackend.new(redis: redis, limit: limit)
+        elsif memory
+          MemoryBackend.new(limit: limit)
+        else
+          raise ArgumentError, "Pass `redis: ...` to store traces in Redis for later review"
+        end
+        schema.detailed_trace = self.new(storage: storage, trace_mode: trace_mode)
+        schema.trace_with(PerfettoTrace, mode: trace_mode, save_profile: true)
+      end
+
+      def initialize(storage:, trace_mode:)
+        @storage = storage
+        @trace_mode = trace_mode
+      end
+
+      # @return [Symbol] The trace mode to use when {Schema.detailed_trace?} returns `true`
+      attr_reader :trace_mode
+
+      # @return [String] ID of saved trace
+      def save_trace(operation_name, duration_ms, begin_ms, trace_data)
+        @storage.save_trace(operation_name, duration_ms, begin_ms, trace_data)
+      end
+
+      # @param last [Integer]
+      # @param before [Integer] Timestamp in milliseconds since epoch
+      # @return [Enumerable<StoredTrace>]
+      def traces(last: nil, before: nil)
+        @storage.traces(last: last, before: before)
+      end
+
+      # @return [StoredTrace, nil]
+      def find_trace(id)
+        @storage.find_trace(id)
+      end
+
+      # @return [void]
+      def delete_trace(id)
+        @storage.delete_trace(id)
+      end
+
+      # @return [void]
+      def delete_all_traces
+        @storage.delete_all_traces
+      end
+
+      class StoredTrace
+        def initialize(id:, operation_name:, duration_ms:, begin_ms:, trace_data:)
+          @id = id
+          @operation_name = operation_name
+          @duration_ms = duration_ms
+          @begin_ms = begin_ms
+          @trace_data = trace_data
+        end
+
+        attr_reader :id, :operation_name, :duration_ms, :begin_ms, :trace_data
+      end
+    end
+  end
+end

data/lib/graphql/tracing/legacy_hooks_trace.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GraphQL
   module Tracing
     module LegacyHooksTrace