graphql-metrics 1.1.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95309c5ed04f9b4c10fe700e9e013ff19d3be644
-  data.tar.gz: 3318e036297987653dae4fc03f28100537426fac
+  metadata.gz: a37ad6af9b19ef274d8f36142f5d73f92c43dc8c
+  data.tar.gz: b6a7180811bbef742741324af59dc6b78d25fb6a
 SHA512:
-  metadata.gz: 95f17afd63cdd64624abee5c8f7595c65bd7c5b0e034a38e36b2b7d64cbb7f2582b6cee4a83ee5e7b58a30c6d977b8a6c2c5d7e1e025dd95197ef16cd59fc8e6
-  data.tar.gz: 177ecdbc69be67a2c7c04463689b4878d66860282d2664abd91abac000af38979a9e994a4f4a87c2ecd53e370c36ef5d77aff77470646c0046aba13fec27b786
+  metadata.gz: 9a6f311bc6c4235ec3390784f13b2b6396a87970e549d2696001755879d0c196fd45275f01953e36bee7120b6db75abaaa7446e5cd95cf175df182d3f1a98dd8
+  data.tar.gz: b483a7642ee22f357a4e116fce3aacfed9e18d9d2f79782ca671e26d284fffc4381f63d599cde5095741e9a0290d0542476763748aec861b3d4907219061248e

data/.gitignore

@@ -7,3 +7,5 @@
 /spec/reports/
 /tmp/
 *.gem
+
+/vendor/

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphql-metrics (1.1.5)
+    graphql-metrics (2.0.0)
 
 GEM
   remote: https://rubygems.org/
@@ -26,6 +26,8 @@ GEM
     metaclass (0.0.4)
     method_source (0.9.0)
     minitest (5.11.3)
+    minitest-focus (1.1.2)
+      minitest (>= 4, < 6)
     mocha (1.5.0)
       metaclass (~> 0.0.1)
     promise.rb (0.7.4)
@@ -53,6 +55,7 @@ DEPENDENCIES
   graphql-batch
   graphql-metrics!
   minitest (~> 5.0)
+  minitest-focus
   mocha
   pry
   pry-byebug

data/README.md

@@ -53,7 +53,7 @@ implementing the methods below, as needed.
 Here's an example of a simple extractor that logs out all GraphQL query details.
 
 ```ruby
-class LoggingExtractor < GraphQLMetrics::Extractor
+class LoggingExtractor < GraphQLMetrics::Instrumentation
   def query_extracted(metrics, _metadata)
     Rails.logger.debug({
       query_string: metrics[:query_string],     # "query Project { project(name: "GraphQL") { tagline } }"
@@ -103,6 +103,7 @@ class LoggingExtractor < GraphQLMetrics::Extractor
       default_value_type: metrics[:default_value_type],   # "IMPLICIT_NULL"
       provided_value: metrics[:provided_value],           # false
       default_used: metrics[:default_used],               # false
+      used_in_operation: metrics[:used_in_operation],     # true
     })
   end
 
@@ -133,6 +134,32 @@ class LoggingExtractor < GraphQLMetrics::Extractor
 end
 ```
 
+You can also define ad hoc query Extractors that can work with instances of GraphQL::Query, for example:
+
+```ruby
+class TypeUsageExtractor < GraphQLMetrics::Extractor
+  attr_reader :types_used
+
+  def initialize
+    @types_used = Set.new
+  end
+
+  def field_extracted(metrics, _metadata)
+    @types_used << metrics[:type_name]
+  end
+end
+
+# ...
+
+extractor = TypeUsageExtractor.new
+extractor.extract!(query)
+puts extractor.types_used
+# => ["Comment", "Post", "QueryRoot"]
+```
+
+Note that resolver-timing related data like `duration` in `query_extracted` and `resolver_times` in `field_extracted`
+won't be available when using an ad hoc Extractor, since the query isn't actually being run; it's only analyzed.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/graphql_metrics.gemspec

@@ -44,4 +44,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "mocha"
   spec.add_development_dependency "diffy"
   spec.add_development_dependency "fakeredis"
+  spec.add_development_dependency "minitest-focus"
 end

data/lib/graphql_metrics/extractor.rb

@@ -2,117 +2,76 @@
 
 module GraphQLMetrics
   class Extractor
-    CONTEXT_NAMESPACE = :extracted_metrics
-    TIMING_CACHE_KEY = :timing_cache
-    START_TIME_KEY = :query_start_time
+    class DummyInstrumentor
+      def after_query_start_and_end_time
+        [nil, nil]
+      end
+
+      def after_query_resolver_times(_ast_node)
+        []
+      end
+
+      def ctx_namespace
+        {}
+      end
+    end
 
     EXPLICIT_NULL = 'EXPLICIT_NULL'
     IMPLICIT_NULL = 'IMPLICIT_NULL'
     NON_NULL = 'NON_NULL'
 
-    attr_reader :query, :ctx_namespace
-
-    def self.use(schema_definition)
-      extractor = self.new
-      return unless extractor.extractor_defines_any_visitors?
-
-      extractor.setup_instrumentation(schema_definition)
-    end
-
-    def use(schema_definition)
-      return unless extractor_defines_any_visitors?
-      setup_instrumentation(schema_definition)
-    end
+    attr_reader :query
 
-    def setup_instrumentation(schema_definition)
-      schema_definition.instrument(:query, self)
-      schema_definition.instrument(:field, self)
+    def initialize(instrumentor = DummyInstrumentor.new)
+      @instrumentor = instrumentor
     end
 
-    def before_query(query)
-      return unless extractor_defines_any_visitors?
-
-      ns = query.context.namespace(CONTEXT_NAMESPACE)
-      ns[TIMING_CACHE_KEY] = {}
-      ns[START_TIME_KEY] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    rescue StandardError => ex
-      handle_extraction_exception(ex)
+    def instrumentor
+      @instrumentor ||= DummyInstrumentor.new
     end
 
-    def after_query(query)
-      return unless extractor_defines_any_visitors?
-
+    def extract!(query)
       @query = query
+
       return unless query.valid?
-      return if respond_to?(:skip_extraction?) && skip_extraction?(query)
-      return unless @ctx_namespace = query.context.namespace(CONTEXT_NAMESPACE)
       return unless query.irep_selection
 
-      before_query_extracted(query, query.context) if respond_to?(:before_query_extracted)
       extract_query
 
+      used_variables = extract_used_variables
+
       query.operations.each_value do |operation|
-        extract_variables(operation)
+        extract_variables(operation, used_variables)
       end
 
       extract_node(query.irep_selection)
       extract_batch_loaders
-
-      after_query_teardown(query) if respond_to?(:after_query_teardown)
-    rescue StandardError => ex
-      handle_extraction_exception(ex)
-    end
-
-    def instrument(type, field)
-      return field unless respond_to?(:field_extracted)
-      return field if type.introspection?
-
-      old_resolve_proc = field.resolve_proc
-      new_resolve_proc = ->(obj, args, ctx) do
-        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        result = old_resolve_proc.call(obj, args, ctx)
-
-        begin
-          next result if respond_to?(:skip_field_resolution_timing?) &&
-            skip_field_resolution_timing?(query, ctx)
-
-          end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
-          ns = ctx.namespace(CONTEXT_NAMESPACE)
-
-          ns[TIMING_CACHE_KEY][ctx.ast_node] ||= []
-          ns[TIMING_CACHE_KEY][ctx.ast_node] << end_time - start_time
-
-          result
-        rescue StandardError => ex
-          handle_extraction_exception(ex)
-          result
-        end
-      end
-
-      field.redefine { resolve(new_resolve_proc) }
     end
 
     def extractor_defines_any_visitors?
-      respond_to?(:query_extracted) ||
-        respond_to?(:field_extracted) ||
-        respond_to?(:argument_extracted) ||
-        respond_to?(:variable_extracted) ||
-        respond_to?(:batch_loaded_field_extracted) ||
-        respond_to?(:before_query_extracted)
+      [self, instrumentor].any? do |extractor_definer|
+        extractor_definer.respond_to?(:query_extracted) ||
+        extractor_definer.respond_to?(:field_extracted) ||
+        extractor_definer.respond_to?(:argument_extracted) ||
+        extractor_definer.respond_to?(:variable_extracted) ||
+        extractor_definer.respond_to?(:batch_loaded_field_extracted) ||
+        extractor_definer.respond_to?(:before_query_extracted)
+      end
     end
 
     def handle_extraction_exception(ex)
       raise ex
     end
 
+    private
+
     def extract_batch_loaders
-      return unless respond_to?(:batch_loaded_field_extracted)
+      return unless batch_loaded_field_extracted_method = extraction_method(:batch_loaded_field_extracted)
 
       TimedBatchExecutor.timings.each do |key, resolve_meta|
         key, identifiers = TimedBatchExecutor.serialize_loader_key(key)
 
-        batch_loaded_field_extracted(
+        batch_loaded_field_extracted_method.call(
           {
             key: key,
             identifiers: identifiers,
@@ -131,19 +90,17 @@ module GraphQLMetrics
     end
 
     def extract_query
-      return unless respond_to?(:query_extracted)
+      return unless query_extracted_method = extraction_method(:query_extracted)
 
-      start_time = ctx_namespace[START_TIME_KEY]
-      return unless start_time
+      start_time, end_time = instrumentor.after_query_start_and_end_time
+      duration = start_time && end_time ? end_time - start_time : nil
 
-      end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
-      query_extracted(
+      query_extracted_method.call(
         {
           query_string: query.document.to_query_string,
           operation_type: query.selected_operation.operation_type,
           operation_name: query.selected_operation_name,
-          duration: end_time - start_time
+          duration: duration
         },
         {
           query: query,
@@ -156,20 +113,22 @@ module GraphQLMetrics
     end
 
     def extract_field(irep_node)
-      return unless respond_to?(:field_extracted)
+      return unless field_extracted_method = extraction_method(:field_extracted)
       return unless irep_node.definition
 
-      field_extracted(
+      resolver_times = instrumentor.after_query_resolver_times(irep_node.ast_node)
+
+      field_extracted_method.call(
         {
           type_name: irep_node.owner_type.name,
           field_name: irep_node.definition.name,
           deprecated: irep_node.definition.deprecation_reason.present?,
-          resolver_times: ctx_namespace.dig(TIMING_CACHE_KEY, irep_node.ast_node) || [],
+          resolver_times: resolver_times || [],
         },
         {
           irep_node: irep_node,
           query: query,
-          ctx_namespace: ctx_namespace
+          ctx_namespace: instrumentor.ctx_namespace
         }
       )
 
@@ -178,9 +137,9 @@ module GraphQLMetrics
     end
 
     def extract_argument(value, irep_node, types)
-      return unless respond_to?(:argument_extracted)
+      return unless argument_extracted_method = extraction_method(:argument_extracted)
 
-      argument_extracted(
+      argument_extracted_method.call(
         {
           name: value.definition.expose_as,
           type: value.definition.type.unwrap.to_s,
@@ -200,8 +159,8 @@ module GraphQLMetrics
       handle_extraction_exception(ex)
     end
 
-    def extract_variables(operation)
-      return unless respond_to?(:variable_extracted)
+    def extract_variables(operation, used_variables)
+      return unless variable_extracted_method = extraction_method(:variable_extracted)
 
       operation.variables.each do |variable|
         value_provided = query.provided_variables.key?(variable.name)
@@ -217,14 +176,15 @@ module GraphQLMetrics
 
         default_used = !value_provided && default_value_type != IMPLICIT_NULL
 
-        variable_extracted(
+        variable_extracted_method.call(
           {
             operation_name: operation.name,
             unwrapped_type_name: unwrapped_type(variable.type),
             type: variable.type.to_query_string,
             default_value_type: default_value_type,
             provided_value: value_provided,
-            default_used: default_used
+            default_used: default_used,
+            used_in_operation: used_variables.include?(variable.name)
           },
           {
             query: query
@@ -235,6 +195,10 @@ module GraphQLMetrics
       handle_extraction_exception(ex)
     end
 
+    def extract_used_variables
+      query.irep_selection.ast_node.variables.each_with_object(Set.new) { |v, set| set << v.name }
+    end
+
     def extract_arguments(irep_node)
       return unless irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field)
 
@@ -292,5 +256,22 @@ module GraphQLMetrics
     rescue StandardError => ex
       handle_extraction_exception(ex)
     end
+
+    def extraction_method(method_name)
+      @extraction_method_cache ||= {}
+      return @extraction_method_cache[method_name] if @extraction_method_cache.has_key?(method_name)
+
+      method = if respond_to?(method_name)
+        method(method_name)
+      elsif instrumentor && instrumentor.respond_to?(method_name)
+        instrumentor.method(method_name)
+      else
+        nil
+      end
+
+      method.tap do |method|
+        @extraction_method_cache[method_name] = method
+      end
+    end
   end
 end

data/lib/graphql_metrics/instrumentation.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module GraphQLMetrics
+  class Instrumentation
+    extend Forwardable
+
+    CONTEXT_NAMESPACE = :extracted_metrics
+    TIMING_CACHE_KEY = :timing_cache
+    START_TIME_KEY = :query_start_time
+
+    attr_reader :ctx_namespace, :query
+    def_delegators :extractor, :extractor_defines_any_visitors?
+
+    def self.use(schema_definition)
+      instrumentation = self.new
+      return unless instrumentation.extractor_defines_any_visitors?
+
+      instrumentation.setup_instrumentation(schema_definition)
+    end
+
+    def self.current_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def use(schema_definition)
+      return unless extractor_defines_any_visitors?
+      extractor.setup_instrumentation(schema_definition)
+    end
+
+    def setup_instrumentation(schema_definition)
+      schema_definition.instrument(:query, self)
+      schema_definition.instrument(:field, self)
+    end
+
+    def extractor
+      @extractor ||= Extractor.new(self)
+    end
+
+    def before_query(query)
+      return unless extractor_defines_any_visitors?
+
+      ns = query.context.namespace(CONTEXT_NAMESPACE)
+      ns[TIMING_CACHE_KEY] = {}
+      ns[START_TIME_KEY] = self.class.current_time
+    rescue StandardError => ex
+      extractor.handle_extraction_exception(ex)
+    end
+
+    def after_query(query)
+      @query = query
+
+      return unless extractor_defines_any_visitors?
+      return if respond_to?(:skip_extraction?) && skip_extraction?(query)
+      return unless @ctx_namespace = query.context.namespace(CONTEXT_NAMESPACE)
+
+      before_query_extracted(query, query.context) if respond_to?(:before_query_extracted)
+
+      extractor.extract!(query)
+
+      after_query_teardown(query) if respond_to?(:after_query_teardown)
+    rescue StandardError => ex
+      extractor.handle_extraction_exception(ex)
+    end
+
+    def instrument(type, field)
+      return field unless respond_to?(:field_extracted) || extractor.respond_to?(:field_extracted)
+      return field if type.introspection?
+
+      old_resolve_proc = field.resolve_proc
+      new_resolve_proc = ->(obj, args, ctx) do
+        start_time = self.class.current_time
+        result = old_resolve_proc.call(obj, args, ctx)
+
+        begin
+          next result if respond_to?(:skip_field_resolution_timing?) &&
+            skip_field_resolution_timing?(query, ctx)
+
+          end_time = self.class.current_time
+
+          ns = ctx.namespace(CONTEXT_NAMESPACE)
+
+          ns[TIMING_CACHE_KEY][ctx.ast_node] ||= []
+          ns[TIMING_CACHE_KEY][ctx.ast_node] << end_time - start_time
+
+          result
+        rescue StandardError => ex
+          extractor.handle_extraction_exception(ex)
+          result
+        end
+      end
+
+      field.redefine { resolve(new_resolve_proc) }
+    end
+
+    def after_query_resolver_times(ast_node)
+      ctx_namespace.dig(Instrumentation::TIMING_CACHE_KEY).fetch(ast_node, [])
+    end
+
+    def after_query_start_and_end_time
+      start_time = ctx_namespace[Instrumentation::START_TIME_KEY]
+      return unless start_time
+
+      [start_time, self.class.current_time]
+    end
+  end
+end

data/lib/graphql_metrics/timed_batch_executor.rb

@@ -55,7 +55,7 @@ module GraphQLMetrics
 
     def resolve(loader)
       @resolve_meta = {
-        start_time: Process.clock_gettime(Process::CLOCK_MONOTONIC),
+        start_time: Instrumentation.current_time,
         current_loader: loader,
         perform_queue_sizes: loader.send(:queue).size
       }
@@ -66,7 +66,7 @@ module GraphQLMetrics
     def around_promise_callbacks
       return super unless @resolve_meta
 
-      end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end_time = Instrumentation.current_time
 
       TIMINGS[@resolve_meta[:current_loader].loader_key] ||= { times: [], perform_queue_sizes: [] }
       TIMINGS[@resolve_meta[:current_loader].loader_key][:times] << end_time - @resolve_meta[:start_time]

data/lib/graphql_metrics/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GraphQLMetrics
-  VERSION = "1.1.5"
+  VERSION = "2.0.0"
 end

data/lib/graphql_metrics.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 require "graphql_metrics/version"
+require "graphql_metrics/instrumentation"
 require "graphql_metrics/extractor"
 require "graphql_metrics/timed_batch_executor"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-metrics
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 2.0.0
 platform: ruby
 authors:
 - Christopher Butcher
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-28 00:00:00.000000000 Z
+date: 2018-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -164,6 +164,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-focus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
   Extract as much much detail as you want from GraphQL queries, served up from your Ruby app and the `graphql` gem.
   Compatible with the `graphql-batch` gem, to extract batch-loaded fields resolution timings.
@@ -186,6 +200,7 @@ files:
 - graphql_metrics.gemspec
 - lib/graphql_metrics.rb
 - lib/graphql_metrics/extractor.rb
+- lib/graphql_metrics/instrumentation.rb
 - lib/graphql_metrics/timed_batch_executor.rb
 - lib/graphql_metrics/version.rb
 homepage: https://github.com/Shopify/graphql-metrics
@@ -208,7 +223,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: GraphQL Metrics Extractor