graphql 1.13.11 → 1.13.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35f3cee96b43dd0aa0306c28a4c7261c76c5e0e0ff5dc0a78470a5b85d763725
-  data.tar.gz: e6729545ff0b5a7936144e21fe0976ea34270415cee90738de2ee47c3acb9e94
+  metadata.gz: '032739327be4e27b1c7d2dbc3d24a5db771a713ec683238da1e9cd850993ff73'
+  data.tar.gz: b8c12e62126d761283086ccda4095812db080611b463bb0770603ea85c965c02
 SHA512:
-  metadata.gz: ee21a26d3b66b2442aa4eb0eeac02ec38d8e5952d286cc7528842cbae690c7b2af1604b2212e856c44b4b8ff35662f8eb391b5119a46e66d77153d97202a90fd
-  data.tar.gz: b6af73d03526e261d3b36ebf4cd39b402e25f4d21294450005a4bd6319fa9f2b5fa592ca8af0014103d7fedcf45483e153187b99d87a4edf12d4105c69010ac5
+  metadata.gz: c1a66366e1cceae9717bf8a4dc902cf9a670cee49e5017d45d7b9375149f579fa54f31ed0d47b73f71552c4b9c62de108f29eaa2ad59a6bc5fcf8cff7bc2bbc8
+  data.tar.gz: d83ce36125d77157290b60d0b66dbb01a7a3c8eac6d5f99c4c025e0e4cc511917d04c01a53357f74fd7554fcbf3ec91d5ead5b25c7a718565a6bf8b198de50fc

data/lib/graphql/argument.rb

@@ -3,7 +3,7 @@ module GraphQL
   # @api deprecated
   class Argument
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access, :deprecation_reason
+    deprecated_accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access, :deprecation_reason
     attr_reader :default_value
     attr_accessor :description, :name, :as, :deprecation_reason
     attr_accessor :ast_node

data/lib/graphql/base_type.rb

@@ -8,7 +8,7 @@ module GraphQL
     include GraphQL::Define::InstanceDefinable
     include GraphQL::Relay::TypeExtensions
 
-    accepts_definitions :name, :description,
+    deprecated_accepts_definitions :name, :description,
         :introspection,
         :default_scalar,
         :default_relay,

data/lib/graphql/define/instance_definable.rb

@@ -167,6 +167,21 @@ ERR
         # Each symbol in `accepts` will be assigned with `{key}=`.
         # The last entry in accepts may be a hash of name-proc pairs for custom definitions.
         def accepts_definitions(*accepts)
+          deprecated_caller = caller(0, 1).first
+          if deprecated_caller.include?("lib/graphql")
+            deprecated_caller = caller(2, 10).find { |c| !c.include?("lib/graphql") }
+          end
+
+          if deprecated_caller
+            GraphQL::Deprecation.warn <<-ERR
+#{self}.accepts_definitions will be removed in GraphQL-Ruby 2.0; use a class-based definition instead. See https://graphql-ruby.org/schema/class_based_api.html.
+  -> called from #{deprecated_caller}
+ERR
+          end
+          deprecated_accepts_definitions(*accepts)
+        end
+
+        def deprecated_accepts_definitions(*accepts)
           new_assignments = if accepts.last.is_a?(Hash)
             accepts.pop.dup
           else

data/lib/graphql/directive.rb

@@ -8,7 +8,7 @@ module GraphQL
   #
   class Directive
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :locations, :name, :description, :arguments, :default_directive, argument: GraphQL::Define::AssignArgument
+    deprecated_accepts_definitions :locations, :name, :description, :arguments, :default_directive, argument: GraphQL::Define::AssignArgument
 
     attr_accessor :locations, :arguments, :name, :description, :arguments_class
     attr_accessor :ast_node

data/lib/graphql/enum_type.rb

@@ -4,7 +4,7 @@ module GraphQL
   class EnumType < GraphQL::BaseType
     extend Define::InstanceDefinable::DeprecatedDefine
 
-    accepts_definitions :values, value: GraphQL::Define::AssignEnumValue
+    deprecated_accepts_definitions :values, value: GraphQL::Define::AssignEnumValue
     ensure_defined(:values, :validate_non_null_input, :coerce_non_null_input, :coerce_result)
     attr_accessor :ast_node
 
@@ -72,7 +72,7 @@ module GraphQL
     class EnumValue
       include GraphQL::Define::InstanceDefinable
       ATTRIBUTES = [:name, :description, :deprecation_reason, :value]
-      accepts_definitions(*ATTRIBUTES)
+      deprecated_accepts_definitions(*ATTRIBUTES)
       attr_accessor(*ATTRIBUTES)
       attr_accessor :ast_node
       ensure_defined(*ATTRIBUTES)

data/lib/graphql/field.rb

@@ -5,7 +5,7 @@ module GraphQL
   # @api deprecated
   class Field
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :description, :deprecation_reason,
+    deprecated_accepts_definitions :name, :description, :deprecation_reason,
       :resolve, :lazy_resolve,
       :type, :arguments,
       :property, :hash_key, :complexity,

data/lib/graphql/input_object_type.rb

@@ -4,7 +4,7 @@ module GraphQL
   class InputObjectType < GraphQL::BaseType
     extend Define::InstanceDefinable::DeprecatedDefine
 
-    accepts_definitions(
+    deprecated_accepts_definitions(
       :arguments, :mutation,
       input_field: GraphQL::Define::AssignArgument,
       argument: GraphQL::Define::AssignArgument

data/lib/graphql/interface_type.rb

@@ -4,7 +4,7 @@ module GraphQL
   class InterfaceType < GraphQL::BaseType
     extend Define::InstanceDefinable::DeprecatedDefine
 
-    accepts_definitions :fields, :orphan_types, :resolve_type, field: GraphQL::Define::AssignObjectField
+    deprecated_accepts_definitions :fields, :orphan_types, :resolve_type, field: GraphQL::Define::AssignObjectField
 
     attr_accessor :fields, :orphan_types, :resolve_type_proc
     attr_writer :type_membership_class

data/lib/graphql/object_type.rb

@@ -4,8 +4,8 @@ module GraphQL
   class ObjectType < GraphQL::BaseType
     extend Define::InstanceDefinable::DeprecatedDefine
 
-    accepts_definitions :interfaces, :fields, :mutation, :relay_node_type, field: GraphQL::Define::AssignObjectField
-    accepts_definitions implements: ->(type, *interfaces, inherit: false) { type.implements(interfaces, inherit: inherit) }
+    deprecated_accepts_definitions :interfaces, :fields, :mutation, :relay_node_type, field: GraphQL::Define::AssignObjectField
+    deprecated_accepts_definitions implements: ->(type, *interfaces, inherit: false) { type.implements(interfaces, inherit: inherit) }
 
     attr_accessor :fields, :mutation, :relay_node_type
     ensure_defined(:fields, :mutation, :interfaces, :relay_node_type)

data/lib/graphql/relay/mutation.rb

@@ -8,7 +8,7 @@ module GraphQL
     # @api deprecated
     class Mutation
       include GraphQL::Define::InstanceDefinable
-      accepts_definitions(
+      deprecated_accepts_definitions(
         :name, :description, :resolve,
         :return_type,
         :return_interfaces,

data/lib/graphql/scalar_type.rb

@@ -4,7 +4,7 @@ module GraphQL
   class ScalarType < GraphQL::BaseType
     extend Define::InstanceDefinable::DeprecatedDefine
 
-    accepts_definitions :coerce, :coerce_input, :coerce_result
+    deprecated_accepts_definitions :coerce, :coerce_input, :coerce_result
     ensure_defined :coerce_non_null_input, :coerce_result
 
     module NoOpCoerce

data/lib/graphql/schema/field.rb

@@ -176,6 +176,8 @@ module GraphQL
 
       # @return Boolean
       attr_reader :relay_node_field
+      # @return Boolean
+      attr_reader :relay_nodes_field
 
       # @return [Boolean] Should we warn if this field's name conflicts with a built-in method?
       def method_conflict_warning?

data/lib/graphql/schema.rb

@@ -161,7 +161,7 @@ module GraphQL
     include LazyHandlingMethods
     extend LazyHandlingMethods
 
-    accepts_definitions \
+    deprecated_accepts_definitions \
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :validate_timeout, :validate_max_errors, :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :resolve_type, :type_error, :parse_error,
@@ -1730,6 +1730,7 @@ module GraphQL
           {
             backtrace: ctx[:backtrace],
             tracers: ctx[:tracers],
+            dataloader: ctx[:dataloader],
           }
         else
           {}

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -17,15 +17,21 @@ module GraphQL
       def platform_trace(platform_key, key, data)
         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, key)
+          end
 
           if key == 'execute_multiplex'
             operations = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
-            span.resource = if operations.empty?
+
+            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?
@@ -39,6 +45,8 @@ module GraphQL
             span.set_tag(:query_string, data[:query].query_string)
           end
 
+          prepare_span(key, data, span)
+
           yield
         end
       end
@@ -47,8 +55,17 @@ module GraphQL
         options.fetch(:service, 'ruby-graphql')
       end
 
+      # 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 tracer
-        options.fetch(:tracer, Datadog.tracer)
+        default_tracer = defined?(Datadog::Tracing) ? Datadog::Tracing : Datadog.tracer
+
+        options.fetch(:tracer, default_tracer)
       end
 
       def analytics_available?

data/lib/graphql/tracing/opentelemetry_tracing.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class OpenTelemetryTracing < PlatformTracing
+      self.platform_keys = {
+        'lex' => 'graphql.lex',
+        'parse' => 'graphql.parse',
+        'validate' => 'graphql.validate',
+        'analyze_query' => 'graphql.analyze_query',
+        'analyze_multiplex' => 'graphql.analyze_multiplex',
+        'execute_query' => 'graphql.execute_query',
+        'execute_query_lazy' => 'graphql.execute_query_lazy',
+        'execute_multiplex' => 'graphql.execute_multiplex'
+      }
+
+      def platform_trace(platform_key, key, data)
+        return yield if platform_key.nil?
+
+        tracer.in_span(platform_key, attributes: attributes_for(key, data)) do |span, _context|
+          yield.tap do |response|
+            errors = response[:errors]&.compact&.map { |e| e.to_h }&.to_json if key == 'validate'
+            unless errors.nil?
+              span.add_event(
+                'graphql.validation.error',
+                attributes: {
+                  'message' => errors
+                }
+              )
+            end
+          end
+        end
+      end
+
+      def platform_field_key(type, field)
+        "#{type.graphql_name}.#{field.graphql_name}"
+      end
+
+      def platform_authorized_key(type)
+        "#{type.graphql_name}.authorized"
+      end
+
+      def platform_resolve_type_key(type)
+        "#{type.graphql_name}.resolve_type"
+      end
+
+      private
+
+      def tracer
+        OpenTelemetry::Instrumentation::GraphQL::Instrumentation.instance.tracer
+      end
+
+      def config
+        OpenTelemetry::Instrumentation::GraphQL::Instrumentation.instance.config
+      end
+
+      def platform_key_enabled?(ctx, key)
+        return false unless config[key]
+
+        ns = ctx.namespace(:opentelemetry)
+        return true if ns.empty? # restores original behavior so that keys are returned if tracing is not set in context.
+        return false unless ns.key?(key) && ns[key]
+
+        return true
+      end
+
+      def attributes_for(key, data)
+        attributes = {}
+        case key
+        when 'execute_query'
+          attributes['selected_operation_name'] = data[:query].selected_operation_name if data[:query].selected_operation_name
+          attributes['selected_operation_type'] = data[:query].selected_operation.operation_type
+          attributes['query_string'] = data[:query].query_string
+        end
+        attributes
+      end
+
+      def cached_platform_key(ctx, key, trace_phase)
+        cache = ctx.namespace(self.class)[:platform_key_cache] ||= {}
+
+        cache.fetch(key) do
+          cache[key] = if trace_phase == :field
+            return unless platform_key_enabled?(ctx, :enable_platform_field)
+
+            yield
+          elsif trace_phase == :authorized
+            return unless platform_key_enabled?(ctx, :enable_platform_authorized)
+
+            yield
+          elsif trace_phase == :resolve_type
+            return unless platform_key_enabled?(ctx, :enable_platform_resolve_type)
+
+            yield
+          else
+            raise "Unknown trace phase"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/platform_tracing.rb

@@ -10,6 +10,10 @@ module GraphQL
     class PlatformTracing
       class << self
         attr_accessor :platform_keys
+
+        def inherited(child_class)
+          child_class.platform_keys = self.platform_keys
+        end
       end
 
       def initialize(options = {})
@@ -41,7 +45,7 @@ module GraphQL
 
             platform_key = if trace_field
               context = data.fetch(:query).context
-              cached_platform_key(context, field) { platform_field_key(data[:owner], field) }
+              cached_platform_key(context, field, :field) { platform_field_key(data[:owner], field) }
             else
               nil
             end
@@ -57,14 +61,14 @@ module GraphQL
         when "authorized", "authorized_lazy"
           type = data.fetch(:type)
           context = data.fetch(:context)
-          platform_key = cached_platform_key(context, type) { platform_authorized_key(type) }
+          platform_key = cached_platform_key(context, type, :authorized) { platform_authorized_key(type) }
           platform_trace(platform_key, key, data) do
             yield
           end
         when "resolve_type", "resolve_type_lazy"
           type = data.fetch(:type)
           context = data.fetch(:context)
-          platform_key = cached_platform_key(context, type) { platform_resolve_type_key(type) }
+          platform_key = cached_platform_key(context, type, :resolve_type) { platform_resolve_type_key(type) }
           platform_trace(platform_key, key, data) do
             yield
           end
@@ -135,7 +139,7 @@ module GraphQL
       # 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)
+      def cached_platform_key(ctx, key, trace_phase)
         cache = ctx.namespace(self.class)[:platform_key_cache] ||= {}
         cache.fetch(key) { cache[key] = yield }
       end

data/lib/graphql/tracing.rb

@@ -9,6 +9,7 @@ require "graphql/tracing/scout_tracing"
 require "graphql/tracing/skylight_tracing"
 require "graphql/tracing/statsd_tracing"
 require "graphql/tracing/prometheus_tracing"
+require "graphql/tracing/opentelemetry_tracing"
 
 if defined?(PrometheusExporter::Server)
   require "graphql/tracing/prometheus_tracing/graphql_collector"

data/lib/graphql/union_type.rb

@@ -11,7 +11,7 @@ module GraphQL
       end
     end
 
-    accepts_definitions :resolve_type, :type_membership_class,
+    deprecated_accepts_definitions :resolve_type, :type_membership_class,
       possible_types: AcceptPossibleTypesDefinition
     ensure_defined :possible_types, :resolve_type, :resolve_type_proc, :type_membership_class
 

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.13.11"
+  VERSION = "1.13.14"
 end

data/lib/graphql.rb

@@ -83,6 +83,7 @@ require "graphql/string_encoding_error"
 require "graphql/date_encoding_error"
 
 require "graphql/define"
+require "graphql/deprecation"
 require "graphql/base_type"
 require "graphql/object_type"
 require "graphql/enum_type"
@@ -119,7 +120,6 @@ require "graphql/internal_representation"
 require "graphql/directive"
 require "graphql/static_validation"
 require "graphql/execution"
-require "graphql/deprecation"
 require "graphql/boolean_type"
 require "graphql/float_type"
 require "graphql/id_type"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.13.11
+  version: 1.13.14
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-21 00:00:00.000000000 Z
+date: 2022-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -659,6 +659,7 @@ files:
 - lib/graphql/tracing/data_dog_tracing.rb
 - lib/graphql/tracing/new_relic_tracing.rb
 - lib/graphql/tracing/notifications_tracing.rb
+- lib/graphql/tracing/opentelemetry_tracing.rb
 - lib/graphql/tracing/platform_tracing.rb
 - lib/graphql/tracing/prometheus_tracing.rb
 - lib/graphql/tracing/prometheus_tracing/graphql_collector.rb
@@ -722,7 +723,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby