Remove instrument documentation, migrate subscriptions and LazyHelpers

Author: rmosolgo

guides/queries/instrumentation.md

@@ -6,6 +6,8 @@ search: true
 section: Queries
 desc: Observation hooks for execution
 index: 11
+redirect_from:
+  - /queries/instrumentation
 ---
 
 {{ "GraphQL::Tracing::Trace" | api_doc }} provides hooks to observe and modify events during runtime. Tracing hooks are methods, defined in modules and mixed in with {{ "Schema.trace_with" | api_doc }}.

guides/queries/tracing.md

@@ -101,19 +101,11 @@ See the {% internal_link "Object Identification guide", "/schema/object_identifi
 
 ## Execution Configuration
 
-__`instrument`__ attaches instrumenters to the schema, see {% internal_link "Instrumentation", "/queries/instrumentation" %} for more information.
+__`trace_with`__ attaches tracer modules, see {% internal_link "Tracing", "/queries/tracing" %} for more.
 
 ```ruby
 class MySchema < GraphQL::Schema
-  instrument :query, ResolveTimerInstrumentation
-end
-```
-
-__`tracer`__ is another way to hook into execution, see {% internal_link "Tracing", "/queries/tracing" %} for more.
-
-```ruby
-class MySchema < GraphQL::Schema
-  tracer MetricTracer
+  trace_with MetricTracer
 end
 ```
 

guides/schema/definition.md

@@ -51,6 +51,9 @@ def run_all(schema, query_options, context: {}, max_complexity: schema.max_compl
               # Do as much eager evaluation of the query as possible
               results = []
               queries.each_with_index do |query, idx|
+                if query.subscription? && !query.subscription_update?
+                  query.context.namespace(:subscriptions)[:events] = []
+                end
                 multiplex.dataloader.append_job {
                   operation = query.selected_operation
                   result = if operation.nil? || !query.valid? || query.context.errors.any?
@@ -96,6 +99,9 @@ def run_all(schema, query_options, context: {}, max_complexity: schema.max_compl
               # Then, find all errors and assign the result to the query object
               results.each_with_index do |data_result, idx|
                 query = queries[idx]
+                if (events = query.context.namespace(:subscriptions)[:events]) && events.any?
+                  schema.subscriptions.write_subscription(query, events)
+                end
                 # Assign the result so that it can be accessed in instrumentation
                 query.result_values = if data_result.equal?(NO_OPERATION)
                   if !query.valid? || query.context.errors.any?

lib/graphql/execution/interpreter.rb

@@ -1044,6 +1044,11 @@ def lazy_resolve(lazy_class, value_method)
       end
 
       def instrument(instrument_step, instrumenter, options = {})
+        warn <<~WARN
+        Schema.instrument is deprecated, use `trace_with` instead: https://graphql-ruby.org/queries/tracing.html"
+          (From `#{self}.instrument(#{instrument_step}, #{instrumenter})` at #{caller(1, 1).first})
+
+        WARN
         trace_with(Tracing::LegacyHooksTrace)
         own_instrumenters[instrument_step] << instrumenter
       end

lib/graphql/schema.rb

@@ -2,7 +2,6 @@
 require "securerandom"
 require "graphql/subscriptions/broadcast_analyzer"
 require "graphql/subscriptions/event"
-require "graphql/subscriptions/instrumentation"
 require "graphql/subscriptions/serialize"
 require "graphql/subscriptions/action_cable_subscriptions"
 require "graphql/subscriptions/default_subscription_resolve_extension"
@@ -30,8 +29,6 @@ def self.use(defn, options = {})
         raise ArgumentError, "Can't reinstall subscriptions. #{schema} is using #{schema.subscriptions}, can't also add #{self}"
       end
 
-      instrumentation = Subscriptions::Instrumentation.new(schema: schema)
-      defn.instrument(:query, instrumentation)
       options[:schema] = schema
       schema.subscriptions = self.new(**options)
       schema.add_subscription_extension_if_necessary

lib/graphql/subscriptions.rb

@@ -124,46 +124,64 @@ def list_sum(values:)
     end
   end
 
-  class SumAllInstrumentation
-    def initialize(counter:)
-      @counter = counter
+  module SumAllInstrumentation
+    def execute_query(query:)
+      add_check(query, "before #{query.selected_operation.name}")
+      super
     end
 
-    def before_query(q)
-      add_check(q, "before #{q.selected_operation.name}")
+    def execute_query_lazy(query:, multiplex:)
+      result = super
+      multiplex.queries.reverse_each do |q|
+        add_check(q, "after #{q.selected_operation.name}")
+      end
+      result
+    end
+
+    def execute_multiplex(multiplex:)
+      add_check(multiplex, "before multiplex 1")
       # TODO not threadsafe
       # This should use multiplex-level context
       SumAll.all.clear
+      result = super
+      add_check(multiplex, "after multiplex 1")
+      result
     end
 
-    def after_query(q)
-      add_check(q, "after #{q.selected_operation.name}")
-    end
+    private
 
-    def before_multiplex(multiplex)
-      add_check(multiplex, "before multiplex #@counter")
+    def add_check(object, text)
+      checks = object.context[:instrumentation_checks]
+      if checks
+        checks << text
+      end
     end
+  end
 
-    def after_multiplex(multiplex)
-      add_check(multiplex, "after multiplex #@counter")
+  module SumAllInstrumentation2
+    def execute_multiplex(multiplex:)
+      add_check(multiplex, "before multiplex 2")
+      result = super
+      add_check(multiplex, "after multiplex 2")
+      result
     end
 
-    def add_check(obj, text)
-      checks = obj.context[:instrumentation_checks]
+    private
+
+    def add_check(object, text)
+      checks = object.context[:instrumentation_checks]
       if checks
         checks << text
       end
     end
   end
-
   class LazySchema < GraphQL::Schema
     query(LazyQuery)
     mutation(LazyQuery)
     lazy_resolve(Wrapper, :item)
     lazy_resolve(SumAll, :value)
-    instrument(:query, SumAllInstrumentation.new(counter: nil))
-    instrument(:multiplex, SumAllInstrumentation.new(counter: 1))
-    instrument(:multiplex, SumAllInstrumentation.new(counter: 2))
+    trace_with(SumAllInstrumentation2)
+    trace_with(SumAllInstrumentation)
 
     def self.sync_lazy(lazy)
       if lazy.is_a?(SumAll) && lazy.own_value > 1000