graphql-metrics 4.0.2 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2af911e9031c446b604b9c296caef2c89f00cb968ecf15350a6a196d6cab08d7
-  data.tar.gz: 94e65ae882fd6222bf3b4ed9395f32dfc395ec00c85e061a458cb5fe54b9dc67
+  metadata.gz: 7c32ac33ad3d4dcce935518115cb51e8b619b4f06e5eaacf6eded57b0393e8d1
+  data.tar.gz: 466c20309ac8e7ca599580f9145c936bbcb76cb29c9f019fa28c3be3c9c46ba7
 SHA512:
-  metadata.gz: aa3ffe4208e67594c3e65786a0a0477cdcee71506dea37988db388433eb155175d87f92e30082931e5e8c493937876e9a5a4043327b74e9e17bc474d58bd4ed9
-  data.tar.gz: e876e9f5907cff0863a6ead3e319f34ab238b1904d0f72c8874420fdf50b5cb2941cb0f77fcfbefac35968c2bb86ec6364c5e338842dcee591eb165ee2ed14d6
+  metadata.gz: fc8fa91436e89b75faa0573007bb20ce3a381019231dcb6131f41a73395b4c62c990be07efadbf437c9f1c67f9a9a03ef328c3d379e57132dcee00332489bf7f
+  data.tar.gz: d465979e9f3b3ea7b7f17c0275a48bd629ab45f80eeb89e69dc7d8040dd8f615e7a23bfefdab0befb04402d192e11dfb818417c65f930dd8fdcdd3eae030715b

data/.gitignore

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

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+4.1.0
+-----
+- [42](https://github.com/Shopify/graphql-metrics/pull/42) Capture timing of the `lex` phase.
+
+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.

data/README.md

@@ -7,6 +7,9 @@ Compatible with the [`graphql-batch` gem](https://github.com/Shopify/graphql-bat
 
 Be sure to read the [CHANGELOG](CHANGELOG.md) to stay updated on feature additions, breaking changes made to this gem.
 
+**NOTE**: Not tested with graphql-ruby's multiplexing feature. Metrics may not
+be accurate if you execute multiple operations at once.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -44,18 +47,16 @@ 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,
+**NOTE**: If any non-`graphql-ruby` gem-related exceptions occur in your application during query document
+parsing and validation, **runtime metrics** 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
@@ -74,10 +75,15 @@ parsing and validation runtime metrics will not be added to the `metrics` hash.
     #   operation_name: "PostDetails",
     #   query_start_time: 1573833076.027327,
     #   query_duration: 2.0207119999686256,
+    #   lexing_start_time_offset: 0.0010339999571442604,
+    #   lexing_duration: 0.0008190000080503523,
     #   parsing_start_time_offset: 0.0010339999571442604,
     #   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
@@ -178,9 +184,6 @@ class Schema < GraphQL::Schema
   query QueryRoot
   mutation MutationRoot
 
-  use GraphQL::Execution::Interpreter # Required.
-  use GraphQL::Analysis::AST # Required.
-
   query_analyzer SimpleAnalyzer
 
   instrument :query, GraphQL::Metrics::Instrumentation.new # Both of these are required if either is used.
@@ -200,9 +203,6 @@ class Schema < GraphQL::Schema
   query QueryRoot
   mutation MutationRoot
 
-  use GraphQL::Execution::Interpreter # Required.
-  use GraphQL::Analysis::AST # Required.
-
   query_analyzer SimpleAnalyzer
 end
 ```
@@ -221,12 +221,15 @@ 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.capture_lexing_time
 * Tracer.capture_parsing_time
+* Tracer.capture_multiplex_start_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.capture_query_start_time
 * Tracer.trace_field (n times)
 * Instrumentation.after_query (call query and field callbacks, now that we have all static and runtime metrics
   gathered)
@@ -250,7 +253,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/graphql_metrics. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/graphql-metrics. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 

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,18 @@ 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
+    LEXING_START_TIME_OFFSET = :lexing_start_time_offset
+    LEXING_DURATION = :lexing_duration
     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,
         }
 

data/lib/graphql/metrics/instrumentation.rb

@@ -45,6 +45,11 @@ module GraphQL
             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],
+            lexing_start_time_offset: ns[GraphQL::Metrics::LEXING_START_TIME_OFFSET],
+            lexing_duration: ns[GraphQL::Metrics::LEXING_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.extract_fields

data/lib/graphql/metrics/tracer.rb

@@ -3,10 +3,15 @@
 module GraphQL
   module Metrics
     class Tracer
-      # NOTE: These constants come from the graphql ruby gem.
-      GRAPHQL_GEM_LEXING_KEY = 'lex'
-      GRAPHQL_GEM_PARSING_KEY = 'parse'
-      GRAPHQL_GEM_VALIDATION_KEYS = ['validate', 'analyze_query']
+      # NOTE: These constants come from the graphql ruby gem and are in "chronological" order based on the phases
+      # of execution of the graphql-ruby gem. Most of them can be run multiple times when multiplexing multiple queries.
+      GRAPHQL_GEM_LEXING_KEY = 'lex' # may not trigger if the query is passed in pre-parsed
+      GRAPHQL_GEM_PARSING_KEY = 'parse' # may not trigger if the query is passed in pre-parsed
+      GRAPHQL_GEM_EXECUTE_MULTIPLEX_KEY = 'execute_multiplex' # wraps everything below this line; only run once
+      GRAPHQL_GEM_VALIDATION_KEY = 'validate'
+      GRAPHQL_GEM_ANALYZE_MULTIPLEX_KEY = 'analyze_multiplex' # wraps all `analyze_query`s; only run once
+      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'
@@ -14,29 +19,32 @@ module GraphQL
 
       def trace(key, data, &block)
         # NOTE: Context doesn't exist yet during lexing, parsing.
-        possible_context = data[:query]&.context
-
-        skip_tracing = possible_context&.fetch(GraphQL::Metrics::SKIP_GRAPHQL_METRICS_ANALYSIS, false)
+        context = data[:query]&.context
+        skip_tracing = context&.fetch(GraphQL::Metrics::SKIP_GRAPHQL_METRICS_ANALYSIS, false)
         return yield if skip_tracing
 
-        # 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)
+          return capture_lexing_time(&block)
         when GRAPHQL_GEM_PARSING_KEY
           return capture_parsing_time(&block)
-        when *GRAPHQL_GEM_VALIDATION_KEYS
-          context = possible_context
-
-          return yield unless context.query.valid?
+        when GRAPHQL_GEM_EXECUTE_MULTIPLEX_KEY
+          return capture_multiplex_start_time(&block)
+        when GRAPHQL_GEM_VALIDATION_KEY
           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
+          return capture_analysis_time(context, &block)
+        when GRAPHQL_GEM_EXECUTE_QUERY_KEY
+          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 if 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 +60,108 @@ module GraphQL
 
       private
 
+      PreContext = Struct.new(
+        :multiplex_start_time,
+        :multiplex_start_time_monotonic,
+        :parsing_start_time_offset,
+        :parsing_duration,
+        :lexing_start_time_offset,
+        :lexing_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_lexing_time
+        # GraphQL::Query#result fires `lex` before the `execute_multiplex` event, so sometimes
+        # `pre_context.multiplex_start_time_monotonic` isn't set.
+        lexing_offset_time = pre_context.multiplex_start_time_monotonic || GraphQL::Metrics.current_time_monotonic
+        timed_result = GraphQL::Metrics.time(lexing_offset_time) { yield }
+
+        pre_context.lexing_start_time_offset = timed_result.start_time
+        pre_context.lexing_duration = timed_result.duration
+
+        timed_result.result
+      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 }
+        # Queries may already be lexed and parsed before execution (whether a single query or multiplex).
+        # If we don't have those values, use some sane defaults.
+        if pre_context.lexing_duration.nil?
+          pre_context.lexing_start_time_offset = pre_context.multiplex_start_time
+          pre_context.lexing_duration = 0.0
+        end
+        if pre_context.parsing_duration.nil?
+          pre_context.parsing_start_time_offset = pre_context.multiplex_start_time
+          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[LEXING_START_TIME_OFFSET] = pre_context.lexing_start_time_offset
+        ns[LEXING_DURATION] = pre_context.lexing_duration
+        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.2"
+    VERSION = "4.1.0"
   end
 end

data/service.yml

@@ -0,0 +1 @@
+classification: library

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-metrics
 version: !ruby/object:Gem::Version
-  version: 4.0.2
+  version: 4.1.0
 platform: ruby
 authors:
 - Christopher Butcher
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-11 00:00:00.000000000 Z
+date: 2021-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -209,9 +209,9 @@ files:
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
+- RELEASING
 - Rakefile
 - bin/console
 - bin/setup
@@ -221,6 +221,7 @@ files:
 - lib/graphql/metrics/instrumentation.rb
 - lib/graphql/metrics/tracer.rb
 - lib/graphql/metrics/version.rb
+- service.yml
 homepage: https://github.com/Shopify/graphql-metrics
 licenses:
 - MIT
@@ -240,7 +241,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: GraphQL Metrics Extractor

data/Gemfile.lock

@@ -1,67 +0,0 @@
-PATH
-  remote: .
-  specs:
-    graphql-metrics (4.0.1)
-      concurrent-ruby (~> 1.1.0)
-      graphql (>= 1.10.8)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activesupport (5.1.7)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-    byebug (11.0.1)
-    coderay (1.1.2)
-    concurrent-ruby (1.1.5)
-    diffy (3.3.0)
-    fakeredis (0.7.0)
-      redis (>= 3.2, < 5.0)
-    graphql (1.10.8)
-    graphql-batch (0.4.2)
-      graphql (>= 1.3, < 2)
-      promise.rb (~> 0.7.2)
-    hashdiff (1.0.0)
-    i18n (1.7.0)
-      concurrent-ruby (~> 1.0)
-    metaclass (0.0.4)
-    method_source (0.9.2)
-    minitest (5.13.0)
-    minitest-focus (1.1.2)
-      minitest (>= 4, < 6)
-    mocha (1.9.0)
-      metaclass (~> 0.0.1)
-    promise.rb (0.7.4)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    pry-byebug (3.7.0)
-      byebug (~> 11.0)
-      pry (~> 0.10)
-    rake (13.0.1)
-    redis (4.1.3)
-    thread_safe (0.3.6)
-    tzinfo (1.2.5)
-      thread_safe (~> 0.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activesupport (~> 5.1.5)
-  diffy
-  fakeredis
-  graphql-batch
-  graphql-metrics!
-  hashdiff
-  minitest (~> 5.0)
-  minitest-focus
-  mocha
-  pry
-  pry-byebug
-  rake
-
-BUNDLED WITH
-   2.1.4