graphql 2.6.9 → 2.6.14

data/lib/graphql/tracing/platform_tracing.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   module Tracing
@@ -6,8 +7,7 @@ module GraphQL
     # - `.platform_keys`
     # - `#platform_trace`
     # - `#platform_field_key(type, field)`
-    # @api private
-    class PlatformTracing
+    class PlatformTracing # :nodoc:
       class << self
         attr_accessor :platform_keys
 
@@ -77,7 +77,8 @@ module GraphQL
           tracer = self.new(**options)
           schema_defn.tracer(tracer)
         else
-          tracing_name = self.name.split("::").last
+          class_name = self.name #: as !nil
+          tracing_name = class_name.split("::").last #: as String
           trace_name = tracing_name.sub("Tracing", "Trace")
           if GraphQL::Tracing.const_defined?(trace_name, false)
             trace_module = GraphQL::Tracing.const_get(trace_name)
@@ -123,10 +124,18 @@ module GraphQL
       #
       # If the key isn't present, the given block is called and the result is cached for `key`.
       #
-      # @param ctx [GraphQL::Query::Context]
-      # @param key [Class, GraphQL::Field] A part of the schema
-      # @param trace_phase [Symbol] The stage of execution being traced (used by OpenTelementry tracing)
-      # @return [String]
+      # **Parameters**
+      #
+      # - `ctx` (`GraphQL::Query::Context`)
+      # - `key` (`Class, GraphQL::Field`) — A part of the schema
+      # - `trace_phase` (`Symbol`) — The stage of execution being traced (used by OpenTelementry tracing)
+      #
+      # **Returns**
+      #
+      # - `String`
+      #
+      # :call-seq:
+      #   cached_platform_key(GraphQL::Query::Context ctx, Class | GraphQL::Field key, Symbol trace_phase) -> String
       def cached_platform_key(ctx, key, trace_phase)
         cache = ctx.namespace(self.class)[:platform_key_cache] ||= {}
         cache.fetch(key) { cache[key] = yield }

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: ignore
 
 require "graphql/tracing"
 

data/lib/graphql/tracing/prometheus_trace.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: ignore
 
 require "graphql/tracing/monitor_trace"
 
@@ -8,24 +9,32 @@ module GraphQL
     #
     # The PrometheusExporter server must be run with a custom type collector that extends `GraphQL::Tracing::PrometheusTracing::GraphQLCollector`.
     #
-    # @example Adding this trace to your schema
-    #   require 'prometheus_exporter/client'
+    # **Examples**
     #
-    #   class MySchema < GraphQL::Schema
-    #     trace_with GraphQL::Tracing::PrometheusTrace
-    #   end
+    # **Example: Adding this trace to your schema**
+    #
+    # ```ruby
+    # require 'prometheus_exporter/client'
+    #
+    # class MySchema < GraphQL::Schema
+    #   trace_with GraphQL::Tracing::PrometheusTrace
+    # end
+    # ```
+    #
+    # **Example: Running a custom type collector**
     #
-    # @example Running a custom type collector
-    #   # lib/graphql_collector.rb
-    #   if defined?(PrometheusExporter::Server)
-    #     require 'graphql/tracing'
+    # ```ruby
+    # # lib/graphql_collector.rb
+    # if defined?(PrometheusExporter::Server)
+    #   require 'graphql/tracing'
     #
-    #     class GraphQLCollector < GraphQL::Tracing::PrometheusTrace::GraphQLCollector
-    #     end
+    #   class GraphQLCollector < GraphQL::Tracing::PrometheusTrace::GraphQLCollector
     #   end
+    # end
     #
-    #    # Then run:
-    #    # bundle exec prometheus_exporter -a lib/graphql_collector.rb
+    #  # Then run:
+    #  # bundle exec prometheus_exporter -a lib/graphql_collector.rb
+    # ```
     PrometheusTrace = MonitorTrace.create_module("prometheus")
     module PrometheusTrace
       if defined?(PrometheusExporter::Server)

data/lib/graphql/tracing/prometheus_tracing.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: ignore
 
 require "graphql/tracing/platform_tracing"
 

data/lib/graphql/tracing/scout_trace.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: ignore
 
 require "graphql/tracing/monitor_trace"
 
@@ -6,10 +7,15 @@ module GraphQL
   module Tracing
     # A tracer for sending GraphQL-Ruby times to Scout
     #
-    # @example Adding this tracer to your schema
-    #   class MySchema < GraphQL::Schema
-    #     trace_with GraphQL::Tracing::ScoutTrace
-    #   end
+    # **Examples**
+    #
+    # **Example: Adding this tracer to your schema**
+    #
+    # ```ruby
+    # class MySchema < GraphQL::Schema
+    #   trace_with GraphQL::Tracing::ScoutTrace
+    # end
+    # ```
     ScoutTrace = MonitorTrace.create_module("scout")
     module ScoutTrace
       class ScoutMonitor < MonitorTrace::Monitor

data/lib/graphql/tracing/scout_tracing.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 require "graphql/tracing/platform_tracing"
 
@@ -18,9 +19,12 @@ 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]`.
+      # **Parameters**
+      #
+      # - `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]`.
+      #
+      # :call-seq:
+      #   initialize(options)
       def initialize(options = {})
         self.class.include ScoutApm::Tracer
         @set_transaction_name = options.fetch(:set_transaction_name, false)

data/lib/graphql/tracing/sentry_trace.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: ignore
 
 require "graphql/tracing/monitor_trace"
 
@@ -6,11 +7,17 @@ module GraphQL
   module Tracing
     # A tracer for reporting GraphQL-Ruby times to Sentry.
     #
-    # @example Installing the tracer
-    #   class MySchema < GraphQL::Schema
-    #     trace_with GraphQL::Tracing::SentryTrace
-    #   end
-    # @see MonitorTrace Configuration Options in the parent module
+    # See [MonitorTrace](rdoc-ref:MonitorTrace) Configuration Options in the parent module
+    #
+    # **Examples**
+    #
+    # **Example: Installing the tracer**
+    #
+    # ```ruby
+    # class MySchema < GraphQL::Schema
+    #   trace_with GraphQL::Tracing::SentryTrace
+    # end
+    # ```
     SentryTrace = MonitorTrace.create_module("sentry")
     module SentryTrace
       class SentryMonitor < MonitorTrace::Monitor
@@ -37,13 +44,18 @@ module GraphQL
                     scope.set_transaction_name(transaction_name(query))
                   end
                 end
-                span.set_data('graphql.document', query.query_string)
+                if graphql_data_collection.nil? || graphql_data_collection.document
+                  span.set_data('graphql.document', query.query_string)
+                end
                 if query.selected_operation_name
                   span.set_data('graphql.operation.name', query.selected_operation_name)
                 end
                 if query.selected_operation
                   span.set_data('graphql.operation.type', query.selected_operation.operation_type)
                 end
+                if graphql_data_collection&.variables && !query.provided_variables.empty?
+                  span.set_data('graphql.variables', query.provided_variables)
+                end
               end
             end
 
@@ -55,6 +67,13 @@ module GraphQL
 
         private
 
+        def graphql_data_collection
+          @graphql_data_collection ||= if Sentry.respond_to?(:configuration)
+            configuration = Sentry.configuration
+            configuration.data_collection.graphql if configuration.respond_to?(:data_collection)
+          end
+        end
+
         def operation_name(query)
           selected_op = query.selected_operation
           if selected_op

data/lib/graphql/tracing/statsd_trace.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: ignore
 
 require "graphql/tracing/monitor_trace"
 
@@ -8,12 +9,17 @@ module GraphQL
     # Passing any Statsd client that implements `.time(name) { ... }`
     # and `.timing(name, ms)` will work.
     #
-    # @example Installing this tracer
-    #   # eg:
-    #   # $statsd = Statsd.new 'localhost', 9125
-    #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Tracing::StatsdTrace, statsd: $statsd
-    #   end
+    # **Examples**
+    #
+    # **Example: Installing this tracer**
+    #
+    # ```ruby
+    # # eg:
+    # # $statsd = Statsd.new 'localhost', 9125
+    # class MySchema < GraphQL::Schema
+    #   use GraphQL::Tracing::StatsdTrace, statsd: $statsd
+    # end
+    # ```
     StatsdTrace = MonitorTrace.create_module("statsd")
     module StatsdTrace
       class StatsdMonitor < MonitorTrace::Monitor

data/lib/graphql/tracing/statsd_tracing.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 require "graphql/tracing/platform_tracing"
 
@@ -16,7 +17,12 @@ module GraphQL
         'execute_query_lazy' => "graphql.execute_query_lazy",
       }
 
-      # @param statsd [Object] A statsd client
+      # **Parameters**
+      #
+      # - `statsd` (`Object`) — A statsd client
+      #
+      # :call-seq:
+      #   initialize(Object statsd:, **rest)
       def initialize(statsd:, **rest)
         @statsd = statsd
         super(**rest)

data/lib/graphql/tracing/trace.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 require "graphql/tracing"
 
@@ -11,8 +12,13 @@ module GraphQL
     # to continue any tracing hooks and call the actual runtime behavior.
     #
     class Trace
-      # @param multiplex [GraphQL::Execution::Multiplex, nil]
-      # @param query [GraphQL::Query, nil]
+      # **Parameters**
+      #
+      # - `multiplex` (`GraphQL::Execution::Multiplex, nil`)
+      # - `query` (`GraphQL::Query, nil`)
+      #
+      # :call-seq:
+      #   initialize(GraphQL::Execution::Multiplex | nil multiplex:, GraphQL::Query | nil query:, **_options)
       def initialize(multiplex: nil, query: nil, **_options)
         @multiplex = multiplex
         @query = query
@@ -23,8 +29,16 @@ module GraphQL
         yield
       end
 
-      # @param query_string [String]
-      # @return [void]
+      # **Parameters**
+      #
+      # - `query_string` (`String`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   parse(String query_string:) -> void
       def parse(query_string:)
         yield
       end
@@ -39,16 +53,40 @@ module GraphQL
       def end_validate(query, validate, errors)
       end
 
-      # @param multiplex [GraphQL::Execution::Multiplex]
-      # @param analyzers [Array<Class>]
-      # @return [void]
+      # **Parameters**
+      #
+      # - `multiplex` (`GraphQL::Execution::Multiplex`)
+      # - `analyzers` (`Array<Class>`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   begin_analyze_multiplex(GraphQL::Execution::Multiplex multiplex, Array[Class] analyzers) -> void
       def begin_analyze_multiplex(multiplex, analyzers); end
-      # @param multiplex [GraphQL::Execution::Multiplex]
-      # @param analyzers [Array<Class>]
-      # @return [void]
+      # **Parameters**
+      #
+      # - `multiplex` (`GraphQL::Execution::Multiplex`)
+      # - `analyzers` (`Array<Class>`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   end_analyze_multiplex(GraphQL::Execution::Multiplex multiplex, Array[Class] analyzers) -> void
       def end_analyze_multiplex(multiplex, analyzers); end
-      # @param multiplex [GraphQL::Execution::Multiplex]
-      # @return [void]
+      # **Parameters**
+      #
+      # - `multiplex` (`GraphQL::Execution::Multiplex`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   analyze_multiplex(GraphQL::Execution::Multiplex multiplex:) -> void
       def analyze_multiplex(multiplex:)
         yield
       end
@@ -58,8 +96,17 @@ module GraphQL
       end
 
       # This wraps an entire `.execute` call.
-      # @param multiplex [GraphQL::Execution::Multiplex]
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `multiplex` (`GraphQL::Execution::Multiplex`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   execute_multiplex(GraphQL::Execution::Multiplex multiplex:) -> void
       def execute_multiplex(multiplex:)
         yield
       end
@@ -73,17 +120,29 @@ module GraphQL
       end
 
       # GraphQL is about to resolve this field
-      # @param field [GraphQL::Schema::Field]
-      # @param object [GraphQL::Schema::Object]
-      # @param arguments [Hash]
-      # @param query [GraphQL::Query]
+      #
+      # **Parameters**
+      #
+      # - `field` (`GraphQL::Schema::Field`)
+      # - `object` (`GraphQL::Schema::Object`)
+      # - `arguments` (`Hash`)
+      # - `query` (`GraphQL::Query`)
+      #
+      # :call-seq:
+      #   begin_execute_field(GraphQL::Schema::Field field, GraphQL::Schema::Object object, Hash arguments, GraphQL::Query query)
       def begin_execute_field(field, object, arguments, query); end
       # GraphQL just finished resolving this field
-      # @param field [GraphQL::Schema::Field]
-      # @param object [GraphQL::Schema::Object]
-      # @param arguments [Hash]
-      # @param query [GraphQL::Query]
-      # @param result [Object]
+      #
+      # **Parameters**
+      #
+      # - `field` (`GraphQL::Schema::Field`)
+      # - `object` (`GraphQL::Schema::Object`)
+      # - `arguments` (`Hash`)
+      # - `query` (`GraphQL::Query`)
+      # - `result` (`Object`)
+      #
+      # :call-seq:
+      #   end_execute_field(GraphQL::Schema::Field field, GraphQL::Schema::Object object, Hash arguments, GraphQL::Query query, Object result)
       def end_execute_field(field, object, arguments, query, result); end
 
       def execute_field(field:, query:, ast_node:, arguments:, object:)
@@ -105,18 +164,36 @@ module GraphQL
       end
 
       # A call to `.authorized?` is starting
-      # @param type [Class<GraphQL::Schema::Object>]
-      # @param object [Object]
-      # @param context [GraphQL::Query::Context]
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `type` (`Class<GraphQL::Schema::Object>`)
+      # - `object` (`Object`)
+      # - `context` (`GraphQL::Query::Context`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   begin_authorized(Class[GraphQL::Schema::Object] type, Object object, GraphQL::Query::Context context) -> void
       def begin_authorized(type, object, context)
       end
       # A call to `.authorized?` just finished
-      # @param type [Class<GraphQL::Schema::Object>]
-      # @param object [Object]
-      # @param context [GraphQL::Query::Context]
-      # @param authorized_result [Boolean]
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `type` (`Class<GraphQL::Schema::Object>`)
+      # - `object` (`Object`)
+      # - `context` (`GraphQL::Query::Context`)
+      # - `authorized_result` (`Boolean`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   end_authorized(Class[GraphQL::Schema::Object] type, Object object, GraphQL::Query::Context context, bool authorized_result) -> void
       def end_authorized(type, object, context, authorized_result)
       end
 
@@ -133,59 +210,155 @@ module GraphQL
       end
 
       # A call to `.resolve_type` is starting
-      # @param type [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
-      # @param value [Object]
-      # @param context [GraphQL::Query::Context]
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `type` (`Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>`)
+      # - `value` (`Object`)
+      # - `context` (`GraphQL::Query::Context`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   begin_resolve_type(Class[GraphQL::Schema::Union] | Module[GraphQL::Schema::Interface] type, Object value, GraphQL::Query::Context context) -> void
       def begin_resolve_type(type, value, context)
       end
 
       # A call to `.resolve_type` just ended
-      # @param type [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
-      # @param value [Object]
-      # @param context [GraphQL::Query::Context]
-      # @param resolved_type [Class<GraphQL::Schema::Object>]
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `type` (`Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>`)
+      # - `value` (`Object`)
+      # - `context` (`GraphQL::Query::Context`)
+      # - `resolved_type` (`Class<GraphQL::Schema::Object>`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   end_resolve_type(Class[GraphQL::Schema::Union] | Module[GraphQL::Schema::Interface] type, Object value, GraphQL::Query::Context context, Class[GraphQL::Schema::Object] resolved_type) -> void
       def end_resolve_type(type, value, context, resolved_type)
       end
 
       # A dataloader run is starting
-      # @param dataloader [GraphQL::Dataloader]
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `dataloader` (`GraphQL::Dataloader`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   begin_dataloader(GraphQL::Dataloader dataloader) -> void
       def begin_dataloader(dataloader); end
       # A dataloader run has ended
-      # @param dataloder [GraphQL::Dataloader]
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `dataloder` (`GraphQL::Dataloader`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   end_dataloader(dataloader) -> void
       def end_dataloader(dataloader); end
 
       # A source with pending keys is about to fetch
-      # @param source [GraphQL::Dataloader::Source]
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `source` (`GraphQL::Dataloader::Source`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   begin_dataloader_source(GraphQL::Dataloader::Source source) -> void
       def begin_dataloader_source(source); end
       # A fetch call has just ended
-      # @param source [GraphQL::Dataloader::Source]
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `source` (`GraphQL::Dataloader::Source`)
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   end_dataloader_source(GraphQL::Dataloader::Source source) -> void
       def end_dataloader_source(source); end
 
       # Called when Dataloader spins up a new fiber for GraphQL execution
-      # @param jobs [Array<#call>] Execution steps to run
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `jobs` (`Array<#call>`) — Execution steps to run
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   dataloader_spawn_execution_fiber(Array[#call] jobs) -> void
       def dataloader_spawn_execution_fiber(jobs); end
       # Called when Dataloader spins up a new fiber for fetching data
-      # @param pending_sources [GraphQL::Dataloader::Source] Instances with pending keys
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `pending_sources` (`GraphQL::Dataloader::Source`) — Instances with pending keys
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   dataloader_spawn_source_fiber(GraphQL::Dataloader::Source pending_sources) -> void
       def dataloader_spawn_source_fiber(pending_sources); end
       # Called when an execution or source fiber terminates
-      # @return [void]
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   dataloader_fiber_exit;() -> void
       def dataloader_fiber_exit; end
 
       # Called when a Dataloader fiber is paused to wait for data
-      # @param source [GraphQL::Dataloader::Source] The Source whose `load` call initiated this `yield`
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `source` (`GraphQL::Dataloader::Source`) — The Source whose `load` call initiated this `yield`
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   dataloader_fiber_yield(GraphQL::Dataloader::Source source) -> void
       def dataloader_fiber_yield(source); end
       # Called when a Dataloader fiber is resumed because data has been loaded
-      # @param source [GraphQL::Dataloader::Source] The Source whose `load` call previously caused this Fiber to wait
-      # @return [void]
+      #
+      # **Parameters**
+      #
+      # - `source` (`GraphQL::Dataloader::Source`) — The Source whose `load` call previously caused this Fiber to wait
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   dataloader_fiber_resume(GraphQL::Dataloader::Source source) -> void
       def dataloader_fiber_resume(source); end
     end
   end