graphql 2.0.28 → 2.1.0

data/lib/graphql/tracing/data_dog_trace.rb

@@ -3,18 +3,20 @@
 module GraphQL
   module Tracing
     module DataDogTrace
-      # @param tracer [#trace] Deprecated
       # @param analytics_enabled [Boolean] Deprecated
       # @param analytics_sample_rate [Float] Deprecated
-      def initialize(tracer: nil, analytics_enabled: false, analytics_sample_rate: 1.0, service: nil, **rest)
+      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_enabled = analytics_enabled
-        @analytics_sample_rate = analytics_sample_rate
+        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
         @has_prepare_span = respond_to?(:prepare_span)
         super
@@ -32,9 +34,12 @@ module GraphQL
       }.each do |trace_method, trace_key|
         module_eval <<-RUBY, __FILE__, __LINE__
           def #{trace_method}(**data)
-            @tracer.trace("#{trace_key}", service: @service_name, type: 'custom') do |span|
-                span.set_tag('component', 'graphql')
-                span.set_tag('operation', '#{trace_method}')
+            @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'
@@ -49,8 +54,10 @@ module GraphQL
                   end
                   span.resource = resource if resource
 
-                  # [Deprecated] will be removed in the future
-                  span.set_metric('_dd1.sr.eausr', @analytics_sample_rate) if @analytics_enabled
+                  # 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
@@ -82,10 +89,12 @@ module GraphQL
           nil
         end
         if platform_key && trace_field
-          @tracer.trace(platform_key, service: @service_name, type: 'custom') do |span|
-            span.set_tag('component', 'graphql')
-            span.set_tag('operation', span_key)
-
+          @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
             if @has_prepare_span
               prepare_span_data = { query: query, field: field, ast_node: ast_node, arguments: arguments, object: object }
               prepare_span(span_key, prepare_span_data, span)
@@ -116,10 +125,12 @@ module GraphQL
 
       def authorized_span(span_key, object, type, query)
         platform_key = @platform_key_cache[DataDogTrace].platform_authorized_key_cache[type]
-        @tracer.trace(platform_key, service: @service_name, type: 'custom') do |span|
-          span.set_tag('component', 'graphql')
-          span.set_tag('operation', span_key)
-
+        @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
           if @has_prepare_span
             prepare_span(span_key, {object: object, type: type, query: query}, span)
           end
@@ -147,10 +158,12 @@ module GraphQL
 
       def resolve_type_span(span_key, object, type, query)
         platform_key = @platform_key_cache[DataDogTrace].platform_resolve_type_key_cache[type]
-        @tracer.trace(platform_key, service: @service_name, type: 'custom') do |span|
-          span.set_tag('component', 'graphql')
-          span.set_tag('operation', span_key)
-
+        @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
           if @has_prepare_span
             prepare_span(span_key, {object: object, type: type, query: query}, span)
           end

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -15,9 +15,12 @@ module GraphQL
       }
 
       def platform_trace(platform_key, key, data)
-        tracer.trace(platform_key, service: options[:service], type: 'custom') do |span|
-          span.set_tag('component', 'graphql')
-          span.set_tag('operation', key)
+        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(', ')
@@ -30,8 +33,10 @@ module GraphQL
             end
             span.resource = resource if resource
 
-            # [Deprecated] will be removed in the future
-            span.set_metric('_dd1.sr.eausr', analytics_sample_rate) if analytics_enabled?
+            # 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
           end
 
           if key == 'execute_query'
@@ -46,6 +51,10 @@ module GraphQL
         end
       end
 
+      def service_name
+        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)
@@ -56,13 +65,18 @@ module GraphQL
       def tracer
         default_tracer = defined?(Datadog::Tracing) ? Datadog::Tracing : Datadog.tracer
 
-        # [Deprecated] options[:tracer] will be removed in the future
         options.fetch(:tracer, default_tracer)
       end
 
+      def analytics_available?
+        defined?(Datadog::Contrib::Analytics) \
+          && Datadog::Contrib::Analytics.respond_to?(:enabled?) \
+          && Datadog::Contrib::Analytics.respond_to?(:set_sample_rate)
+      end
+
       def analytics_enabled?
         # [Deprecated] options[:analytics_enabled] will be removed in the future
-        options.fetch(:analytics_enabled, false)
+        analytics_available? && Datadog::Contrib::Analytics.enabled?(options.fetch(:analytics_enabled, false))
       end
 
       def analytics_sample_rate

data/lib/graphql/types/relay/connection_behaviors.rb

@@ -67,9 +67,8 @@ module GraphQL
               type: [edge_type_class, null: edge_nullable],
               null: edges_nullable,
               description: "A list of edges.",
+              scope: false, # Assume that the connection was already scoped.
               connection: false,
-              # Assume that the connection was scoped before this step:
-              scope: false,
             }
 
             if field_options
@@ -170,6 +169,24 @@ module GraphQL
             obj_type.field :page_info, GraphQL::Types::Relay::PageInfo, null: false, description: "Information to aid in pagination."
           end
         end
+
+        def edges
+          # Assume that whatever authorization needed to happen
+          # already happened at the connection level.
+          current_runtime_state = Thread.current[:__graphql_runtime_info]
+          query_runtime_state = current_runtime_state[context.query]
+          query_runtime_state.was_authorized_by_scope_items = @object.was_authorized_by_scope_items?
+          @object.edges
+        end
+
+        def nodes
+          # Assume that whatever authorization needed to happen
+          # already happened at the connection level.
+          current_runtime_state = Thread.current[:__graphql_runtime_info]
+          query_runtime_state = current_runtime_state[context.query]
+          query_runtime_state.was_authorized_by_scope_items = @object.was_authorized_by_scope_items?
+          @object.nodes
+        end
       end
     end
   end

data/lib/graphql/types/relay/edge_behaviors.rb

@@ -12,6 +12,13 @@ module GraphQL
           child_class.node_nullable(true)
         end
 
+        def node
+          current_runtime_state = Thread.current[:__graphql_runtime_info]
+          query_runtime_state = current_runtime_state[context.query]
+          query_runtime_state.was_authorized_by_scope_items = @object.was_authorized_by_scope_items?
+          @object.node
+        end
+
         module ClassMethods
           def inherited(child_class)
             super

data/lib/graphql/version.rb

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

data/lib/graphql.rb

@@ -103,7 +103,6 @@ require "graphql/schema"
 require "graphql/query"
 require "graphql/types"
 require "graphql/dataloader"
-require "graphql/filter"
 require "graphql/static_validation"
 require "graphql/execution"
 require "graphql/schema/built_in_types"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.28
+  version: 2.1.0
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-25 00:00:00.000000000 Z
+date: 2023-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -331,7 +331,6 @@ files:
 - lib/graphql/execution/lookahead.rb
 - lib/graphql/execution/multiplex.rb
 - lib/graphql/execution_error.rb
-- lib/graphql/filter.rb
 - lib/graphql/integer_decoding_error.rb
 - lib/graphql/integer_encoding_error.rb
 - lib/graphql/introspection.rb
@@ -536,7 +535,6 @@ files:
 - lib/graphql/static_validation/rules/variables_are_input_types_error.rb
 - lib/graphql/static_validation/rules/variables_are_used_and_defined.rb
 - lib/graphql/static_validation/rules/variables_are_used_and_defined_error.rb
-- lib/graphql/static_validation/type_stack.rb
 - lib/graphql/static_validation/validation_context.rb
 - lib/graphql/static_validation/validation_timeout_error.rb
 - lib/graphql/static_validation/validator.rb
@@ -623,7 +621,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.5
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby

data/lib/graphql/filter.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-require "graphql/deprecation"
-
-module GraphQL
-  # @api private
-  class Filter
-    def initialize(only: nil, except: nil, silence_deprecation_warning: false)
-      if !silence_deprecation_warning
-        line = caller(2, 10).find { |l| !l.include?("lib/graphql") }
-        GraphQL::Deprecation.warn("GraphQL::Filter, `only:`, `except:`, and `.merge_filters` are deprecated and will be removed in v2.1.0. Implement `visible?` on your schema members instead (https://graphql-ruby.org/authorization/visibility.html).\n  #{line}")
-      end
-      @only = only
-      @except = except
-    end
-
-    # Returns true if `member, ctx` passes this filter
-    def call(member, ctx)
-      (@only ? @only.call(member, ctx) : true) &&
-      (@except ? !@except.call(member, ctx) : true)
-    end
-
-    def merge(only: nil, except: nil)
-      onlies = [self].concat(Array(only))
-      merged_only = MergedOnly.build(onlies)
-      merged_except = MergedExcept.build(Array(except))
-      self.class.new(only: merged_only, except: merged_except, silence_deprecation_warning: true)
-    end
-
-    private
-
-    class MergedOnly
-      def initialize(first, second)
-        @first = first
-        @second = second
-      end
-
-      def call(member, ctx)
-        @first.call(member, ctx) && @second.call(member, ctx)
-      end
-
-      def self.build(onlies)
-        case onlies.size
-        when 0
-          nil
-        when 1
-          onlies[0]
-        else
-          onlies.reduce { |memo, only| self.new(memo, only) }
-        end
-      end
-    end
-
-    class MergedExcept < MergedOnly
-      def call(member, ctx)
-        @first.call(member, ctx) || @second.call(member, ctx)
-      end
-    end
-  end
-end

data/lib/graphql/static_validation/type_stack.rb

@@ -1,216 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module StaticValidation
-    # - Ride along with `GraphQL::Language::Visitor`
-    # - Track type info, expose it to validators
-    class TypeStack
-      # These are jumping-off points for infering types down the tree
-      TYPE_INFERRENCE_ROOTS = [
-        GraphQL::Language::Nodes::OperationDefinition,
-        GraphQL::Language::Nodes::FragmentDefinition,
-      ]
-
-      # @return [GraphQL::Schema] the schema whose types are present in this document
-      attr_reader :schema
-
-      # When it enters an object (starting with query or mutation root), it's pushed on this stack.
-      # When it exits, it's popped off.
-      # @return [Array<GraphQL::ObjectType, GraphQL::Union, GraphQL::Interface>]
-      attr_reader :object_types
-
-      # When it enters a field, it's pushed on this stack (useful for nested fields, args).
-      # When it exits, it's popped off.
-      # @return [Array<GraphQL::Field>] fields which have been entered
-      attr_reader :field_definitions
-
-      # Directives are pushed on, then popped off while traversing the tree
-      # @return [Array<GraphQL::Node::Directive>] directives which have been entered
-      attr_reader :directive_definitions
-
-      # @return [Array<GraphQL::Node::Argument>] arguments which have been entered
-      attr_reader :argument_definitions
-
-      # @return [Array<String>] fields which have been entered (by their AST name)
-      attr_reader :path
-
-      # @param schema [GraphQL::Schema] the schema whose types to use when climbing this document
-      # @param visitor [GraphQL::Language::Visitor] a visitor to follow & watch the types
-      def initialize(schema, visitor)
-        @schema = schema
-        @object_types = []
-        @field_definitions = []
-        @directive_definitions = []
-        @argument_definitions = []
-        @path = []
-
-        PUSH_STRATEGIES.each do |node_class, strategy|
-          visitor[node_class].enter << EnterWithStrategy.new(self, strategy)
-          visitor[node_class].leave << LeaveWithStrategy.new(self, strategy)
-        end
-      end
-
-      private
-
-
-      module FragmentWithTypeStrategy
-        def push(stack, node)
-          object_type = if node.type
-            stack.schema.get_type(node.type.name)
-          else
-            stack.object_types.last
-          end
-          if !object_type.nil?
-            object_type = object_type.unwrap
-          end
-          stack.object_types.push(object_type)
-          push_path_member(stack, node)
-        end
-
-        def pop(stack, node)
-          stack.object_types.pop
-          stack.path.pop
-        end
-      end
-
-      module FragmentDefinitionStrategy
-        extend FragmentWithTypeStrategy
-        module_function
-        def push_path_member(stack, node)
-          stack.path.push("fragment #{node.name}")
-        end
-      end
-
-      module InlineFragmentStrategy
-        extend FragmentWithTypeStrategy
-        module_function
-        def push_path_member(stack, node)
-          stack.path.push("...#{node.type ? " on #{node.type.to_query_string}" : ""}")
-        end
-      end
-
-      module OperationDefinitionStrategy
-        module_function
-        def push(stack, node)
-          # eg, QueryType, MutationType
-          object_type = stack.schema.root_type_for_operation(node.operation_type)
-          stack.object_types.push(object_type)
-          stack.path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
-        end
-
-        def pop(stack, node)
-          stack.object_types.pop
-          stack.path.pop
-        end
-      end
-
-      module FieldStrategy
-        module_function
-        def push(stack, node)
-          parent_type = stack.object_types.last
-          parent_type = parent_type.unwrap
-
-          field_definition = stack.schema.get_field(parent_type, node.name)
-          stack.field_definitions.push(field_definition)
-          if !field_definition.nil?
-            next_object_type = field_definition.type
-            stack.object_types.push(next_object_type)
-          else
-            stack.object_types.push(nil)
-          end
-          stack.path.push(node.alias || node.name)
-        end
-
-        def pop(stack, node)
-          stack.field_definitions.pop
-          stack.object_types.pop
-          stack.path.pop
-        end
-      end
-
-      module DirectiveStrategy
-        module_function
-        def push(stack, node)
-          directive_defn = stack.schema.directives[node.name]
-          stack.directive_definitions.push(directive_defn)
-        end
-
-        def pop(stack, node)
-          stack.directive_definitions.pop
-        end
-      end
-
-      module ArgumentStrategy
-        module_function
-        # Push `argument_defn` onto the stack.
-        # It's possible that `argument_defn` will be nil.
-        # Push it anyways so `pop` has something to pop.
-        def push(stack, node)
-          if stack.argument_definitions.last
-            arg_type = stack.argument_definitions.last.type.unwrap
-            if arg_type.kind.input_object?
-              argument_defn = arg_type.arguments[node.name]
-            else
-              argument_defn = nil
-            end
-          elsif stack.directive_definitions.last
-            argument_defn = stack.directive_definitions.last.arguments[node.name]
-          elsif stack.field_definitions.last
-            argument_defn = stack.field_definitions.last.arguments[node.name]
-          else
-            argument_defn = nil
-          end
-          stack.argument_definitions.push(argument_defn)
-          stack.path.push(node.name)
-        end
-
-        def pop(stack, node)
-          stack.argument_definitions.pop
-          stack.path.pop
-        end
-      end
-
-      module FragmentSpreadStrategy
-        module_function
-        def push(stack, node)
-          stack.path.push("... #{node.name}")
-        end
-
-        def pop(stack, node)
-          stack.path.pop
-        end
-      end
-
-      PUSH_STRATEGIES = {
-        GraphQL::Language::Nodes::FragmentDefinition => FragmentDefinitionStrategy,
-        GraphQL::Language::Nodes::InlineFragment => InlineFragmentStrategy,
-        GraphQL::Language::Nodes::FragmentSpread => FragmentSpreadStrategy,
-        GraphQL::Language::Nodes::Argument => ArgumentStrategy,
-        GraphQL::Language::Nodes::Field => FieldStrategy,
-        GraphQL::Language::Nodes::Directive => DirectiveStrategy,
-        GraphQL::Language::Nodes::OperationDefinition => OperationDefinitionStrategy,
-      }
-
-      class EnterWithStrategy
-        def initialize(stack, strategy)
-          @stack = stack
-          @strategy = strategy
-        end
-
-        def call(node, parent)
-          @strategy.push(@stack, node)
-        end
-      end
-
-      class LeaveWithStrategy
-        def initialize(stack, strategy)
-          @stack = stack
-          @strategy = strategy
-        end
-
-        def call(node, parent)
-          @strategy.pop(@stack, node)
-        end
-      end
-    end
-  end
-end