graphql-metrics 4.0.1 → 4.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45de407a0b5642ad74d27cdb4ab00635590a38d8b719fc448a3e94d6244d7daf
-  data.tar.gz: cae841292ce06f25031974127696594b426b41f469e4f7f74f37f1f3a8c8f521
+  metadata.gz: 794d916d7f0b35ed8c50814c7cee54af5881a9fa5102eb361d1486fde665b413
+  data.tar.gz: 831cd8c26e771fc5e97e483f5cda86bce63311c0a31a9d12a020cdf5be808241
 SHA512:
-  metadata.gz: 861b2728422d3f8c314024084497ef761c4ca83491f3967ccffa2d540ced0de524d318a380f7966b6555a539fd30ffdfaec83cafee42f020813875148434f734
-  data.tar.gz: 83bde1129c7492cd92ffc097e3072275f179262530a5fccbe6e61b5c485a08bb231a3af8e29ddf88a6f0f3cdfdf5bd7101f0266e042afe37d19232a07195d922
+  metadata.gz: aed42769f9dcbcb445e0e9b8ec9858d05c917542fa0c588bcc587d19c2fbc8bafd2d1fcf65f4d7742cd498a2ac1d39b66c6955827efa4da3582a44980f2346e1
+  data.tar.gz: 908bc4cf5d126d71e715379cd2346308b5e7ed17230ad4733eff2614827625768d0ec1186da282628c91c6ab3fe7dd3a92adc6b6e9e548b202eb3b9507f6a8fd

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+4.0.6
+-----
+- [35](https://github.com/Shopify/graphql-metrics/pull/35) Fix query start time, start time offset bugs.
+
+4.0.5
+-----
+- [34](https://github.com/Shopify/graphql-metrics/pull/34) Fix default of pre-parsed query `parsing_duration` to be Float (`0.0`) rather than Integer (`0`).
+
+4.0.4
+-----
+- [33](https://github.com/Shopify/graphql-metrics/pull/33) Setup tracing using lex or execute_multiplex tracer events.
+
+4.0.3
+-----
+- [32](https://github.com/Shopify/graphql-metrics/pull/32) Split validate and analyze_query tracer events (encompasses #30).
+- [30](https://github.com/Shopify/graphql-metrics/pull/30) Handle queries that have already been parsed (thank you @jturkel).
+- [29](https://github.com/Shopify/graphql-metrics/pull/29) Remove runtime dependency on activesupport (thank you @jturkel).
+
+4.0.2
+-----
+- [25](https://github.com/Shopify/graphql-metrics/pull/25) Safely handle interrupted runtime metrics.
+
 4.0.1
 -----
 - [24](https://github.com/Shopify/graphql-metrics/pull/24) Safely call `arguments_for` to handle arguments which may

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphql-metrics (4.0.1)
+    graphql-metrics (4.0.6)
       concurrent-ruby (~> 1.1.0)
       graphql (>= 1.10.8)
 

data/README.md

@@ -5,6 +5,8 @@
 Extract as much much detail as you want from GraphQL queries, served up from your Ruby app and the [`graphql` gem](https://github.com/rmosolgo/graphql-ruby).
 Compatible with the [`graphql-batch` gem](https://github.com/Shopify/graphql-batch), to extract batch-loaded fields resolution timings.
 
+Be sure to read the [CHANGELOG](CHANGELOG.md) to stay updated on feature additions, breaking changes made to this gem.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -42,11 +44,18 @@ etc.
 
 What you do with these captured metrics is up to you!
 
+**NOTE**: Runtime metrics on for queries (like `query_duration`, `parsing_start_time_offset` etc.) as well as field
+resolver timings (like `resolver_timings`, `lazy_resolver_timings`) may not be present in the extracted `metrics` hash,
+even if you opt to collect them by using `GraphQL::Metrics::Analyzer` and `GraphQL::Metrics::Tracer`.
+
+More specifically, if any non-`graphql-ruby` gem-related exceptions occur in your application during query document
+parsing and validation runtime metrics will not be added to the `metrics` hash.
+
 ### Define your own analyzer subclass
 
 ```ruby
-  class CaptureAllMetricsAnalyzer < GraphQL::Metrics::Analyzer
-    ANALYZER_NAMESPACE = :capture_all_metrics_analyzer_namespace
+  class SimpleAnalyzer < GraphQL::Metrics::Analyzer
+    ANALYZER_NAMESPACE = :simple_analyzer_namespace
 
     def initialize(query_or_multiplex)
       super
@@ -69,6 +78,9 @@ What you do with these captured metrics is up to you!
     #   parsing_duration: 0.0008190000080503523,
     #   validation_start_time_offset: 0.0030819999519735575,
     #   validation_duration: 0.01704599999357015,
+    #   analysis_start_time_offset: 0.0010339999571442604,
+    #   analysis_duration: 0.0008190000080503523,
+    #   multiplex_start_time: 0.0008190000080503523,
     # }
     #
     # You can use these metrics to track high-level query performance, along with any other details you wish to
@@ -173,7 +185,7 @@ class Schema < GraphQL::Schema
   use GraphQL::Analysis::AST # Required.
 
   query_analyzer SimpleAnalyzer
-  
+
   instrument :query, GraphQL::Metrics::Instrumentation.new # Both of these are required if either is used.
   tracer GraphQL::Metrics::Tracer.new                      # <-- Note!
 
@@ -212,10 +224,11 @@ your application as intended, here's a breakdown of the order of execution of th
 
  When used as instrumentation, an analyzer and tracing, the order of execution is:
 
-* Tracer.setup_tracing_before_lexing
+* Tracer.setup_tracing
 * Tracer.capture_parsing_time
 * Instrumentation.before_query (context setup)
-* Tracer.capture_validation_time (twice, once for `analyze_query`, then `analyze_multiplex`)
+* Tracer.capture_validation_time
+* Tracer.capture_analysis_time
 * Analyzer#initialize (bit more context setup, instance vars setup)
 * Analyzer#result
 * Tracer.trace_field (n times)

data/RELEASING

@@ -0,0 +1,15 @@
+Releasing graphql-metrics
+
+1. Check the Semantic Versioning page for info on how to version the new release: http://semver.org
+2. Update VERSION in lib/graphql/metrics/version.rb
+3. Add a CHANGELOG entry for the new release
+4. Commit the changes with a commit message like "Packaging for release X.Y.Z"
+5. Tag the release with the version (Leave REV blank for HEAD or provide a SHA)
+  $ git tag vX.Y.Z REV
+6. Push out the changes
+  $ git push
+7. Push out the tags
+  $ git push --tags
+8. Publish the gem
+  $ gem build graphql_metrics.gemspec
+  $ gem push graphql-metrics-X.Y.Z.gem

data/lib/graphql/metrics.rb

@@ -22,12 +22,16 @@ module GraphQL
     ANALYZER_INSTANCE_KEY = :analyzer_instance
 
     # Context keys to store timings for query phases of execution, field resolver timings.
+    MULTIPLEX_START_TIME = :multiplex_start_time
+    MULTIPLEX_START_TIME_MONOTONIC = :multiplex_start_time_monotonic
     QUERY_START_TIME = :query_start_time
     QUERY_START_TIME_MONOTONIC = :query_start_time_monotonic
     PARSING_START_TIME_OFFSET = :parsing_start_time_offset
     PARSING_DURATION = :parsing_duration
     VALIDATION_START_TIME_OFFSET = :validation_start_time_offset
     VALIDATION_DURATION = :validation_duration
+    ANALYSIS_START_TIME_OFFSET = :analysis_start_time_offset
+    ANALYSIS_DURATION = :analysis_duration
     INLINE_FIELD_TIMINGS = :inline_field_timings
     LAZY_FIELD_TIMINGS = :lazy_field_timings
 

data/lib/graphql/metrics/analyzer.rb

@@ -50,7 +50,7 @@ module GraphQL
           field_name: node.name,
           return_type_name: visitor.type_definition.graphql_name,
           parent_type_name: visitor.parent_type_definition.graphql_name,
-          deprecated: visitor.field_definition.deprecation_reason.present?,
+          deprecated: !visitor.field_definition.deprecation_reason.nil?,
           path: visitor.response_path,
         }
 
@@ -61,17 +61,20 @@ module GraphQL
         end
       end
 
-      def extract_fields_with_runtime_metrics
+      def extract_fields(with_runtime_metrics: true)
         return if query.context[SKIP_FIELD_AND_ARGUMENT_METRICS]
 
         ns = query.context.namespace(CONTEXT_NAMESPACE)
 
         @static_field_metrics.each do |static_metrics|
-          resolver_timings = ns[GraphQL::Metrics::INLINE_FIELD_TIMINGS][static_metrics[:path]]
-          lazy_resolver_timings = ns[GraphQL::Metrics::LAZY_FIELD_TIMINGS][static_metrics[:path]]
 
-          static_metrics[:resolver_timings] = resolver_timings || []
-          static_metrics[:lazy_resolver_timings] = lazy_resolver_timings || []
+          if with_runtime_metrics
+            resolver_timings = ns[GraphQL::Metrics::INLINE_FIELD_TIMINGS][static_metrics[:path]]
+            lazy_resolver_timings = ns[GraphQL::Metrics::LAZY_FIELD_TIMINGS][static_metrics[:path]]
+
+            static_metrics[:resolver_timings] = resolver_timings || []
+            static_metrics[:lazy_resolver_timings] = lazy_resolver_timings || []
+          end
 
           field_extracted(static_metrics)
         end

data/lib/graphql/metrics/instrumentation.rb

@@ -25,23 +25,34 @@ module GraphQL
         return if query.context[GraphQL::Metrics::SKIP_GRAPHQL_METRICS_ANALYSIS]
 
         ns = query.context.namespace(CONTEXT_NAMESPACE)
+        analyzer = ns[GraphQL::Metrics::ANALYZER_INSTANCE_KEY]
 
-        # NOTE: The start time stored at `ns[GraphQL::Metrics::QUERY_START_TIME_MONOTONIC]` is captured during query
-        # parsing, which occurs before `Instrumentation#before_query`.
-        query_duration = GraphQL::Metrics.current_time_monotonic - ns[GraphQL::Metrics::QUERY_START_TIME_MONOTONIC]
+        if runtime_metrics_interrupted?(ns)
+          # If runtime metrics were interrupted, then it's most likely that the application raised an exception and that
+          # query parsing (which is instrumented by GraphQL::Metrics::Tracer) was abruptly stopped.
+          #
+          # In this scenario, we still attempt to log whatever static query metrics we've collected, with runtime
+          # metrics (like query, field resolver timings) excluded.
+          analyzer.extract_fields(with_runtime_metrics: false)
+          analyzer.extract_query
+        else
+          query_duration = GraphQL::Metrics.current_time_monotonic - ns[GraphQL::Metrics::QUERY_START_TIME_MONOTONIC]
 
-        runtime_query_metrics = {
-          query_start_time: ns[GraphQL::Metrics::QUERY_START_TIME],
-          query_duration: query_duration,
-          parsing_start_time_offset: ns[GraphQL::Metrics::PARSING_START_TIME_OFFSET],
-          parsing_duration: ns[GraphQL::Metrics::PARSING_DURATION],
-          validation_start_time_offset: ns[GraphQL::Metrics::VALIDATION_START_TIME_OFFSET],
-          validation_duration: ns[GraphQL::Metrics::VALIDATION_DURATION],
-        }
+          runtime_query_metrics = {
+            query_start_time: ns[GraphQL::Metrics::QUERY_START_TIME],
+            query_duration: query_duration,
+            parsing_start_time_offset: ns[GraphQL::Metrics::PARSING_START_TIME_OFFSET],
+            parsing_duration: ns[GraphQL::Metrics::PARSING_DURATION],
+            validation_start_time_offset: ns[GraphQL::Metrics::VALIDATION_START_TIME_OFFSET],
+            validation_duration: ns[GraphQL::Metrics::VALIDATION_DURATION],
+            analysis_start_time_offset: ns[GraphQL::Metrics::ANALYSIS_START_TIME_OFFSET],
+            analysis_duration: ns[GraphQL::Metrics::ANALYSIS_DURATION],
+            multiplex_start_time: ns[GraphQL::Metrics::MULTIPLEX_START_TIME],
+          }
 
-        analyzer = ns[GraphQL::Metrics::ANALYZER_INSTANCE_KEY]
-        analyzer.extract_fields_with_runtime_metrics
-        analyzer.extract_query(runtime_query_metrics: runtime_query_metrics)
+          analyzer.extract_fields
+          analyzer.extract_query(runtime_query_metrics: runtime_query_metrics)
+        end
       end
 
       private
@@ -51,6 +62,12 @@ module GraphQL
         # which did not reject "empty" documents in its parser.
         query.valid? && !query.selected_operation.nil?
       end
+
+      def runtime_metrics_interrupted?(context_namespace)
+        # NOTE: The start time stored at `ns[GraphQL::Metrics::QUERY_START_TIME_MONOTONIC]` is captured during query
+        # parsing, which occurs before `Instrumentation#before_query`.
+        context_namespace.key?(GraphQL::Metrics::QUERY_START_TIME_MONOTONIC) == false
+      end
     end
   end
 end

data/lib/graphql/metrics/tracer.rb

@@ -4,9 +4,12 @@ module GraphQL
   module Metrics
     class Tracer
       # NOTE: These constants come from the graphql ruby gem.
-      GRAPHQL_GEM_LEXING_KEY = 'lex'
+      GRAPHQL_GEM_EXECUTE_MULTIPLEX_KEY = 'execute_multiplex'
       GRAPHQL_GEM_PARSING_KEY = 'parse'
-      GRAPHQL_GEM_VALIDATION_KEYS = ['validate', 'analyze_query']
+      GRAPHQL_GEM_VALIDATION_KEY = 'validate'
+      GRAPHQL_GEM_ANALYZE_MULTIPLEX_KEY = 'analyze_multiplex'
+      GRAPHQL_GEM_ANALYZE_QUERY_KEY = 'analyze_query'
+      GRAPHQL_GEM_EXECUTE_QUERY_KEY = 'execute_query'
       GRAPHQL_GEM_TRACING_FIELD_KEYS = [
         GRAPHQL_GEM_TRACING_FIELD_KEY = 'execute_field',
         GRAPHQL_GEM_TRACING_LAZY_FIELD_KEY = 'execute_field_lazy'
@@ -22,21 +25,28 @@ module GraphQL
         # NOTE: Not all tracing events are handled here, but those that are are handled in this case statement in
         # chronological order.
         case key
-        when GRAPHQL_GEM_LEXING_KEY
-          return setup_tracing_before_lexing(&block)
+        when GRAPHQL_GEM_EXECUTE_MULTIPLEX_KEY
+          return capture_multiplex_start_time(&block)
         when GRAPHQL_GEM_PARSING_KEY
           return capture_parsing_time(&block)
-        when *GRAPHQL_GEM_VALIDATION_KEYS
+        when GRAPHQL_GEM_VALIDATION_KEY
           context = possible_context
-
-          return yield unless context.query.valid?
           return capture_validation_time(context, &block)
+        when GRAPHQL_GEM_ANALYZE_MULTIPLEX_KEY
+          # Ensures that we reset potentially long-lived PreContext objects between multiplexs. We reset at this point
+          # since all parsing and validation will be done by this point, and a GraphQL::Query::Context will exist.
+          pre_context.reset
+          return yield
+        when GRAPHQL_GEM_ANALYZE_QUERY_KEY
+          context = possible_context
+          return capture_analysis_time(context, &block)
+        when GRAPHQL_GEM_EXECUTE_QUERY_KEY
+          context = possible_context
+          capture_query_start_time(context, &block)
         when *GRAPHQL_GEM_TRACING_FIELD_KEYS
           return yield if data[:query].context[SKIP_FIELD_AND_ARGUMENT_METRICS]
           return yield unless GraphQL::Metrics.timings_capture_enabled?(data[:query].context)
 
-          pre_context = nil
-
           context_key = case key
           when GRAPHQL_GEM_TRACING_FIELD_KEY
             GraphQL::Metrics::INLINE_FIELD_TIMINGS
@@ -52,44 +62,90 @@ module GraphQL
 
       private
 
+      PreContext = Struct.new(
+        :multiplex_start_time,
+        :multiplex_start_time_monotonic,
+        :parsing_start_time_offset,
+        :parsing_duration
+      ) do
+        def reset
+          self[:multiplex_start_time] = nil
+          self[:multiplex_start_time_monotonic] = nil
+          self[:parsing_start_time_offset] = nil
+          self[:parsing_duration] = nil
+        end
+      end
+
       def pre_context
         # NOTE: This is used to store timings from lexing, parsing, validation, before we have a context to store
         # values in. Uses thread-safe Concurrent::ThreadLocalVar to store a set of values per thread.
-        @pre_context ||= Concurrent::ThreadLocalVar.new(OpenStruct.new)
+        @pre_context ||= Concurrent::ThreadLocalVar.new(PreContext.new)
+        @pre_context.value
       end
 
-      def setup_tracing_before_lexing
-        pre_context.value.query_start_time = GraphQL::Metrics.current_time
-        pre_context.value.query_start_time_monotonic = GraphQL::Metrics.current_time_monotonic
+      def capture_multiplex_start_time
+        pre_context.multiplex_start_time = GraphQL::Metrics.current_time
+        pre_context.multiplex_start_time_monotonic = GraphQL::Metrics.current_time_monotonic
 
         yield
       end
 
       def capture_parsing_time
-        timed_result = GraphQL::Metrics.time { yield }
+        # GraphQL::Query#result fires `parse` before the `execute_multiplex` event, so sometimes
+        # `pre_context.multiplex_start_time_monotonic` isn't set.
+        parsing_offset_time = pre_context.multiplex_start_time_monotonic || GraphQL::Metrics.current_time_monotonic
+        timed_result = GraphQL::Metrics.time(parsing_offset_time) { yield }
 
-        pre_context.value.parsing_start_time_offset = timed_result.start_time
-        pre_context.value.parsing_duration = timed_result.duration
+        pre_context.parsing_start_time_offset = timed_result.start_time
+        pre_context.parsing_duration = timed_result.duration
 
         timed_result.result
       end
 
+      # Also consolidates parsing timings (if any) from the `pre_context`
       def capture_validation_time(context)
-        timed_result = GraphQL::Metrics.time(pre_context.value.query_start_time_monotonic) { yield }
+        if pre_context.parsing_duration.nil?
+          # Queries may already be parsed before execution (whether a single query or multiplex).
+          # If we don't have a parsing start time, use the multiplex start time.
+          pre_context.parsing_start_time_offset = pre_context.multiplex_start_time
+
+          # If we don't have a duration, consider parsing to have been instantaneous.
+          pre_context.parsing_duration = 0.0
+        end
+
+        timed_result = GraphQL::Metrics.time(pre_context.multiplex_start_time_monotonic) { yield }
 
         ns = context.namespace(CONTEXT_NAMESPACE)
-        previous_validation_duration = ns[GraphQL::Metrics::VALIDATION_DURATION] || 0
 
-        ns[QUERY_START_TIME] = pre_context.value.query_start_time
-        ns[QUERY_START_TIME_MONOTONIC] = pre_context.value.query_start_time_monotonic
-        ns[PARSING_START_TIME_OFFSET] = pre_context.value.parsing_start_time_offset
-        ns[PARSING_DURATION] = pre_context.value.parsing_duration
+        ns[MULTIPLEX_START_TIME] = pre_context.multiplex_start_time
+        ns[MULTIPLEX_START_TIME_MONOTONIC] = pre_context.multiplex_start_time_monotonic
+        ns[PARSING_START_TIME_OFFSET] = pre_context.parsing_start_time_offset
+        ns[PARSING_DURATION] = pre_context.parsing_duration
         ns[VALIDATION_START_TIME_OFFSET] = timed_result.time_since_offset
-        ns[VALIDATION_DURATION] = timed_result.duration + previous_validation_duration
+        ns[VALIDATION_DURATION] = timed_result.duration
 
         timed_result.result
       end
 
+      def capture_analysis_time(context)
+        ns = context.namespace(CONTEXT_NAMESPACE)
+
+        timed_result = GraphQL::Metrics.time(ns[MULTIPLEX_START_TIME_MONOTONIC]) { yield }
+
+        ns[ANALYSIS_START_TIME_OFFSET] = timed_result.time_since_offset
+        ns[ANALYSIS_DURATION] = timed_result.duration
+
+        timed_result.result
+      end
+
+      def capture_query_start_time(context)
+        ns = context.namespace(CONTEXT_NAMESPACE)
+        ns[QUERY_START_TIME] = GraphQL::Metrics.current_time
+        ns[QUERY_START_TIME_MONOTONIC] = GraphQL::Metrics.current_time_monotonic
+
+        yield
+      end
+
       def trace_field(context_key, data)
         ns = data[:query].context.namespace(CONTEXT_NAMESPACE)
         query_start_time_monotonic = ns[GraphQL::Metrics::QUERY_START_TIME_MONOTONIC]

data/lib/graphql/metrics/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Metrics
-    VERSION = "4.0.1"
+    VERSION = "4.0.6"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-metrics
 version: !ruby/object:Gem::Version
-  version: 4.0.1
+  version: 4.0.6
 platform: ruby
 authors:
 - Christopher Butcher
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-05 00:00:00.000000000 Z
+date: 2020-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -212,6 +212,7 @@ files:
 - Gemfile.lock
 - LICENSE.txt
 - README.md
+- RELEASING
 - Rakefile
 - bin/console
 - bin/setup