graphql-metrics 5.0.8 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f54fe0807d964c7ddf402984339caf1c29ba21953db7090ecbf948051048e5ee
-  data.tar.gz: 694a4221b1673386f3104cd8bc0c5e5518f95505cdbbf7330cb98ee7e555bf1a
+  metadata.gz: a07023fbdc4beff81a392ca7dc3ae2e5c413807be91121b49ad05bb63e9f9a20
+  data.tar.gz: c8c533731167efe52c0da74f1d5ee147bd69efb9e3c2eedd0a7a7302d956a187
 SHA512:
-  metadata.gz: f35acb43fde5fdb41b00e2f5fa4e99c2d478bf062630320e521134c8190a0820d81bf0aad9edc3882690a08c5b323998fbc41d1c98542d130e726a1982211fd9
-  data.tar.gz: 7c7d3874d910f1587e65f95c163a12d236e86b5b92b58cbaaa51061e7b0420092357c2f2af87c393fba65174e8ef76ab928a7da5fdc22d984c17740484032087
+  metadata.gz: e6f0d75f489119e17d55fc83d8bfe0aa0601ccb54dc5fa5e97fa435746b130ffe5dd1f95114be8c40c44f6350b2357381986c3602e317c7c76b10bc98b233c7e
+  data.tar.gz: 35613ab78775485ede19e0ba178f7151e2239b091e4b7832e9fcba06c7c97cba7cecddea05042cad131f426c877e96156a54cc91afee2d4c5e33973673f7bb3a

data/.github/dependabot.yml

@@ -0,0 +1,20 @@
+version: 2
+registries:
+  ruby-shopify:
+    type: rubygems-server
+    url: https://pkgs.shopify.io/basic/gems/ruby
+    username: ${{secrets.RUBYGEMS_SERVER_PKGS_SHOPIFY_IO_USERNAME}}
+    password: ${{secrets.RUBYGEMS_SERVER_PKGS_SHOPIFY_IO_PASSWORD}}
+  github-com:
+    type: git
+    url: https://github.com
+    username: ${{secrets.DEPENDENCIES_GITHUB_USER}}
+    password: ${{secrets.DEPENDENCIES_GITHUB_TOKEN}}
+updates:
+  - package-ecosystem: bundler
+    directory: "/"
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 100
+    insecure-external-code-execution: allow
+    registries: "*"

data/.github/workflows/dependabot_auto_merge.yml

@@ -0,0 +1,23 @@
+name: Dependabot auto-merge
+on: pull_request_target
+
+permissions:
+  pull-requests: write
+  contents: write
+
+jobs:
+  dependabot:
+    runs-on: ubuntu-latest
+    if: ${{ github.event.pull_request.user.login == 'dependabot[bot]' }}
+    steps:
+      - name: Dependabot metadata
+        id: metadata
+        uses: dependabot/fetch-metadata@v2
+        with:
+          github-token: "${{ secrets.GITHUB_TOKEN }}"
+      - name: Enable auto-merge for Dependabot PRs
+        if: ${{ steps.metadata.outputs.update-type == 'version-update:semver-patch' }}
+        run: gh pr merge --auto --merge "$PR_URL"
+        env:
+          PR_URL: ${{ github.event.pull_request.html_url }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

data/.github/workflows/ruby.yml

@@ -1,13 +1,17 @@
 name: Tests
-on: [push, pull_request]
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: '0 8 * * 1'
 jobs:
   test:
     strategy:
       fail-fast: false
       matrix:
         os: [ubuntu-latest]
-        ruby: ['2.7', '3.0', '3.1', '3.2']
-        gemfile: ['graphql_1.13', 'graphql_2.0', 'graphql_head']
+        ruby: ['2.7', '3.0', '3.1', '3.2', '3.3']
+        gemfile: ['graphql_2.3', 'graphql_head']
     runs-on: ${{ matrix.os }}
     env:
       BUNDLE_GEMFILE: ${{ github.workspace }}/gemfiles/${{ matrix.gemfile }}.gemfile

data/.gitignore

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

data/.rubocop.yml

@@ -1,5 +1,2 @@
 inherit_from:
   - http://shopify.github.io/ruby-style-guide/rubocop.yml
-
-AllCops:
-  TargetRubyVersion: 2.6

data/.ruby-version

@@ -1 +1 @@
-3.2.0
+3.3.1

data/CHANGELOG.md

@@ -1,3 +1,42 @@
+6.0.0
+-----
+
+**Usage change**
+Due to Instrumentation plugins being deprecated in the `graphql` gem, `graphql-metrics` has been refactored to use the [new `Tracing` API](https://graphql-ruby.org/queries/tracing.html).
+This changes how `graphql-metrics` is used in your application.
+
+Before:
+```ruby
+class MySchema < GraphQL::Schema
+  instrument :query, GraphQLMetrics::Instrumentation.new
+  query_analyzer MyMetricsAnalyzer
+  tracer GraphQL::Metrics::Tracer.new
+end
+```
+
+After:
+```ruby
+class MySchema < GraphQL::Schema
+  use GraphQL::Metrics, analyzer: MyMetricsAnalyzer
+end
+```
+
+Other breaking changes:
+* `graphql` >= 2.3 is now required.
+* Apollo tracing spec support has been removed (the spec has been deprecated for years). All `start_time_offset` metrics have been removed.
+* Support for the old tracing API has been removed.
+* The `multiplex_start_time_monotonic` operation mettric has been removed.
+
+
+Changes:
+- [87](https://github.com/Shopify/graphql-metrics/pull/87) Migrate Instrumentation to tracing
+- [88](https://github.com/Shopify/graphql-metrics/pull/88) Update `analyzer` option
+- [86](https://github.com/Shopify/graphql-metrics/pull/86) Refactor static metric mode
+- [85](https://github.com/Shopify/graphql-metrics/pull/85) Remove old tracing API support
+- [84](https://github.com/Shopify/graphql-metrics/pull/84) Remove Apollo tracing spec support
+- [80](https://github.com/Shopify/graphql-metrics/pull/80) Support new parser
+- [79](https://github.com/Shopify/graphql-metrics/pull/79) Centralize Ruby Version to `.ruby-version`
+
 5.0.8
 -----
 - [76](https://github.com/Shopify/graphql-metrics/pull/76) Reduce object allocations

data/Gemfile.lock

@@ -0,0 +1,70 @@
+PATH
+  remote: .
+  specs:
+    graphql-metrics (6.0.0)
+      graphql (>= 2.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (6.1.7.5)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    base64 (0.2.0)
+    byebug (11.1.3)
+    coderay (1.1.3)
+    concurrent-ruby (1.2.3)
+    diffy (3.4.2)
+    fakeredis (0.9.2)
+      redis (~> 4.8)
+    graphql (2.3.0)
+      base64
+    graphql-batch (0.6.0)
+      graphql (>= 1.12.18, < 3)
+      promise.rb (~> 0.7.2)
+    hashdiff (1.1.0)
+    i18n (1.14.4)
+      concurrent-ruby (~> 1.0)
+    method_source (1.0.0)
+    minitest (5.22.3)
+    minitest-focus (1.4.0)
+      minitest (>= 4, < 6)
+    mocha (2.1.0)
+      ruby2_keywords (>= 0.0.5)
+    promise.rb (0.7.4)
+    pry (0.14.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.10.1)
+      byebug (~> 11.0)
+      pry (>= 0.13, < 0.15)
+    rake (13.1.0)
+    redis (4.8.1)
+    ruby2_keywords (0.0.5)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.6.13)
+
+PLATFORMS
+  arm64-darwin-23
+  x86_64-linux
+
+DEPENDENCIES
+  activesupport (~> 6.1.7)
+  diffy
+  fakeredis
+  graphql-batch
+  graphql-metrics!
+  hashdiff
+  minitest (~> 5.0)
+  minitest-focus
+  mocha
+  pry
+  pry-byebug
+  rake
+
+BUNDLED WITH
+   2.4.1

data/README.md

@@ -7,9 +7,6 @@ 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:
@@ -42,15 +39,15 @@ Get started by defining your own Analyzer, inheriting from `GraphQL::Metrics::An
 
 The following analyzer demonstrates a simple way to capture commonly used metrics sourced from key parts of your schema
 definition, the query document being served, as well as runtime query and resolver timings. In this toy example, all of
-this data is simply stored on the GraphQL::Query context, under a namespace to avoid collisions with other analyzers
+this data is simply stored on the `GraphQL::Query` context, under a namespace to avoid collisions with other analyzers
 etc.
 
 What you do with these captured metrics is up to you!
 
 **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
+parsing and validation, **runtime metrics** for queries (like `query_duration`, 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`.
+even if you opt to collect them.
 
 ### Define your own analyzer subclass
 
@@ -75,15 +72,10 @@ even if you opt to collect them by using `GraphQL::Metrics::Analyzer` and `Graph
     #   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
@@ -129,12 +121,10 @@ even if you opt to collect them by using `GraphQL::Metrics::Analyzer` and `Graph
     #   deprecated: false,
     #   path: ["post", "id"],
     #   resolver_timings: [
-    #     start_time_offset: 0.011901999998372048,
-    #     duration: 5.999987479299307e-06
+    #     5.999987479299307e-06,
     #   ],
     #   lazy_resolver_timings: [
-    #     start_time_offset: 0.031901999998372048,
-    #     duration: 5.999987479299307e-06
+    #     5.999987479299307e-06,
     #   ],
     # }
     def field_extracted(metrics)
@@ -178,12 +168,12 @@ even if you opt to collect them by using `GraphQL::Metrics::Analyzer` and `Graph
   end
 ```
 
-Once defined, you can opt into capturing all metrics seen above by simply including GraphQL::Metrics as a plugin on your
+Once defined, you can opt into capturing all metrics seen above by simply including `GraphQL::Metrics` as a plugin on your
 schema.
-#### Metrics that are captured for arguments for fields and directives
 
-Let's have a query example
+#### Metrics that are captured for arguments for fields and directives
 
+Example query:
 ```graphql
 query PostDetails($postId: ID!, $commentsTags: [String!] = null, $val: Int!) @customDirective(val: $val) {
   post(id: $postId) {
@@ -242,46 +232,48 @@ These are some of the arguments that are extracted
 
 ### Make use of your analyzer
 
-Ensure that your schema is using the graphql-ruby 1.9+ `GraphQL::Execution::Interpreter` and `GraphQL::Analysis::AST`
-engine, and then simply add the below `GraphQL::Metrics` plugins.
-
-This opts you in to capturing all static and runtime metrics seen above.
+Add the `GraphQL::Metrics` plugin to your schema. This opts you in to capturing all static and runtime metrics seen above.
 
 ```ruby
 class Schema < GraphQL::Schema
   query QueryRoot
   mutation MutationRoot
 
-  query_analyzer SimpleAnalyzer
-
-  instrument :query, GraphQL::Metrics::Instrumentation.new # Both of these are required if either is used.
-  tracer GraphQL::Metrics::Tracer.new                      # <-- Note!
-
-  use GraphQL::Batch # Optional, but highly recommended. See https://github.com/Shopify/graphql-batch/.
+  use GraphQL::Metrics, analyzer: SimpleAnalyzer
 end
 ```
 
 ### Optionally, only gather static metrics
 
-If you don't care to capture runtime metrics like query and resolver timings, you can use your analyzer a standalone
-analyzer without `GraphQL::Metrics::Instrumentation` and `tracer GraphQL::Metrics::Tracer`, like so:
+If you don't care to capture field timings metrics, they can be disabled with the `capture_field_timings` option:
 
 ```ruby
 class Schema < GraphQL::Schema
   query QueryRoot
   mutation MutationRoot
 
-  query_analyzer SimpleAnalyzer
+  use GraphQL::Metrics, analyzer: SimpleAnalyzer, capture_field_timings: false
 end
 ```
 
 Your analyzer will still be called with `query_extracted`, `field_extracted`, but with timings metrics omitted.
-`argument_extracted` will work exactly the same, whether instrumentation and tracing are used or not.
+`argument_extracted` will work exactly the same.
+
+And if you want to disable tracing metrics entirely, use the `capture_timings` option:
+
+```ruby
+class Schema < GraphQL::Schema
+  query QueryRoot
+  mutation MutationRoot
+
+  use GraphQL::Metrics, analyzer: SimpleAnalyzer, capture_timings: false
+end
+```
 
 ## Order of execution
 
 Because of the structure of graphql-ruby's plugin architecture, it may be difficult to build an intuition around the
-order in which methods defined on `GraphQL::Metrics::Instrumentation`, `GraphQL::Metrics::Tracer` and subclasses of
+order in which methods defined on `GraphQL::Metrics::Instrumentation`, `GraphQL::Metrics::Trace` and subclasses of
 `GraphQL::Metrics::Analyzer` run.
 
 Although you ideally will not need to care about these details if you are simply using this gem to gather metrics in
@@ -289,30 +281,21 @@ 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 usually:
 
-* Tracer.capture_multiplex_start_time
-* Tracer.capture_lexing_time
-* Tracer.capture_parsing_time
-* Instrumentation.before_query (context setup)
-* Tracer.capture_validation_time
-* Tracer.capture_analysis_time
+* Instrumentation.execute_multiplex (context setup)
+* Trace.capture_lexing_time
+* Trace.capture_parsing_time
+* Trace.capture_validation_time
+* Trace.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)
+* Trace.capture_query_start_time
+* Trace.trace_field (n times)
+* Instrumentation.execute_multiplex (call query and field callbacks, now that we have all static and runtime metrics gathered)
 * Analyzer#extract_query
 * Analyzer#query_extracted
 * Analyzer#extract_fields_with_runtime_metrics
   * calls Analyzer#field_extracted n times
 
-When used as a simple analyzer, which doesn't gather or emit any runtime metrics (timings, arg values):
-* Analyzer#initialize
-* Analyzer#field_extracted n times
-* Analyzer#result
-* Analyzer#extract_query
-* Analyzer#query_extracted
-
 ## 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/gemfiles/{graphql_1.13.gemfile → graphql_2.3.gemfile}

@@ -2,4 +2,4 @@
 
 eval_gemfile("../Gemfile")
 
-gem("graphql", "~> 1.13")
+gem("graphql", "~> 2.3")

data/graphql_metrics.gemspec

@@ -14,6 +14,8 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/Shopify/graphql-metrics'
   spec.license       = "MIT"
 
+  spec.required_ruby_version = ">= 2.7"
+
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
@@ -23,12 +25,11 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "graphql", ">= 1.12.10"
-  spec.add_runtime_dependency "concurrent-ruby", ">= 1.1.0"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_runtime_dependency "graphql", ">= 2.3"
+  spec.add_development_dependency "rake", "~> 13.2"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency 'graphql-batch'
-  spec.add_development_dependency "activesupport", "~> 5.1.5"
+  spec.add_development_dependency "activesupport", "~> 6.1.7"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "mocha"

data/lib/graphql/metrics/analyzer.rb

@@ -51,20 +51,13 @@ module GraphQL
           path: visitor.response_path,
         }
 
-        if GraphQL::Metrics.timings_capture_enabled?(query.context)
-          @static_field_metrics << static_metrics
-        else
-          field_extracted(static_metrics)
-        end
+        @static_field_metrics << static_metrics
       end
 
       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|
-
           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]]
@@ -89,14 +82,6 @@ module GraphQL
       end
 
       def result
-        return if GraphQL::Metrics.timings_capture_enabled?(query.context)
-        return if query.context[GraphQL::Metrics::SKIP_GRAPHQL_METRICS_ANALYSIS]
-
-        # NOTE: If we're running as a static analyzer (i.e. not with instrumentation and tracing), we still need to
-        # flush static query metrics somewhere other than `after_query`.
-        ns = query.context.namespace(CONTEXT_NAMESPACE)
-        analyzer = ns[GraphQL::Metrics::ANALYZER_INSTANCE_KEY]
-        analyzer.extract_query
       end
 
       private

data/lib/graphql/metrics/instrumentation.rb

@@ -2,28 +2,39 @@
 
 module GraphQL
   module Metrics
-    class Instrumentation
-      def before_query(query)
-        unless query_present_and_valid?(query)
-          # Setting this prevents Analyzer and Tracer from trying to gather runtime metrics for invalid queries.
-          query.context[GraphQL::Metrics::SKIP_GRAPHQL_METRICS_ANALYSIS] = true
+    module Instrumentation
+      def initialize(capture_field_timings: true, **_options)
+        @capture_field_timings = capture_field_timings
+
+        super
+      end
+
+      def execute_multiplex(multiplex:)
+        return super if multiplex.context[GraphQL::Metrics::SKIP_GRAPHQL_METRICS_ANALYSIS]
+
+        result = nil
+
+        multiplex.queries.each do |query|
+          ns = query.context.namespace(CONTEXT_NAMESPACE)
+          ns[GraphQL::Metrics::TIMINGS_CAPTURE_ENABLED] = @capture_field_timings
+          ns[GraphQL::Metrics::INLINE_FIELD_TIMINGS] = Hash.new { |h, k| h[k] = [] }
+          ns[GraphQL::Metrics::LAZY_FIELD_TIMINGS] = Hash.new { |h, k| h[k] = [] }
         end
 
-        # Even if queries are present and valid, applications may set this context value in order to opt out of
-        # having Analyzer and Tracer gather runtime metrics.
-        # If we're skipping runtime metrics, then both Instrumentation before_ and after_query can and should be
-        # short-circuited as well.
-        return if query.context[GraphQL::Metrics::SKIP_GRAPHQL_METRICS_ANALYSIS]
+        begin
+          result = super
+        ensure
+          multiplex.queries.each do |query|
+            handle_query(query) if query.valid?
+          end
+        end
 
-        ns = query.context.namespace(CONTEXT_NAMESPACE)
-        ns[GraphQL::Metrics::TIMINGS_CAPTURE_ENABLED] = true
-        ns[GraphQL::Metrics::INLINE_FIELD_TIMINGS] = {}
-        ns[GraphQL::Metrics::LAZY_FIELD_TIMINGS] = {}
+        result
       end
 
-      def after_query(query)
-        return if query.context[GraphQL::Metrics::SKIP_GRAPHQL_METRICS_ANALYSIS]
+      private
 
+      def handle_query(query)
         ns = query.context.namespace(CONTEXT_NAMESPACE)
         analyzer = ns[GraphQL::Metrics::ANALYZER_INSTANCE_KEY]
 
@@ -41,30 +52,19 @@ module GraphQL
           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],
-            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
+          analyzer.extract_fields(with_runtime_metrics: @capture_field_timings)
           analyzer.extract_query(runtime_query_metrics: runtime_query_metrics)
         end
       end
 
       private
 
-      def query_present_and_valid?(query)
-        # Check for selected_operation as well for graphql 1.9 compatibility
-        # 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`.

data/lib/graphql/metrics/trace.rb

@@ -8,6 +8,8 @@ module GraphQL
 
         query_or_multiplex = @query || @multiplex
         @skip_tracing = query_or_multiplex.context&.fetch(SKIP_GRAPHQL_METRICS_ANALYSIS, false) if query_or_multiplex
+        @parsing_duration = 0.0
+        @lexing_duration = 0.0
       end
 
       # NOTE: These methods come from the graphql ruby gem and are in "chronological" order based on the phases
@@ -15,12 +17,6 @@ module GraphQL
       # https://github.com/rmosolgo/graphql-ruby/issues/3393). Most of them can be run multiple times when
       # multiplexing multiple queries.
 
-      # wraps everything below this line; only run once
-      def execute_multiplex(multiplex:)
-        return super if skip_tracing?(multiplex)
-        capture_multiplex_start_time { super }
-      end
-
       # may not trigger if the query is passed in pre-parsed
       def lex(query_string:)
         return super if @skip_tracing
@@ -34,139 +30,74 @@ module GraphQL
       end
 
       def validate(query:, validate:)
-        return super if skip_tracing?(query)
+        return super if @skip_tracing
         capture_validation_time(query.context) { super }
       end
 
-      # wraps all `analyze_query`s; only run once
-      def analyze_multiplex(multiplex:)
-        return super if skip_tracing?(multiplex)
-        # 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
-        super
-      end
-
       def analyze_query(query:)
-        return super if skip_tracing?(query)
+        return super if @skip_tracing
         capture_analysis_time(query.context) { super }
       end
 
       def execute_query(query:)
-        return super if skip_tracing?(query)
+        return super if @skip_tracing
         capture_query_start_time(query.context) { super }
       end
 
       def execute_field(field:, query:, ast_node:, arguments:, object:)
-        return super if skip_tracing?(query) || query.context[SKIP_FIELD_AND_ARGUMENT_METRICS]
-        return super unless GraphQL::Metrics.timings_capture_enabled?(query.context)
+        return super if @skip_tracing || query.context[SKIP_FIELD_AND_ARGUMENT_METRICS]
+        return super unless capture_field_timings?(query.context)
         trace_field(GraphQL::Metrics::INLINE_FIELD_TIMINGS, query) { super }
       end
 
       def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
-        return super if skip_tracing?(query) || query.context[SKIP_FIELD_AND_ARGUMENT_METRICS]
-        return super unless GraphQL::Metrics.timings_capture_enabled?(query.context)
+        return super if @skip_tracing || query.context[SKIP_FIELD_AND_ARGUMENT_METRICS]
+        return super unless capture_field_timings?(query.context)
         trace_field(GraphQL::Metrics::LAZY_FIELD_TIMINGS, query) { super }
       end
 
       private
 
-      def skip_tracing?(query_or_multiplex)
-        if !defined?(@skip_tracing)
-          @skip_tracing = query_or_multiplex.context&.fetch(SKIP_GRAPHQL_METRICS_ANALYSIS, false)
+      def capture_field_timings?(context)
+        if !defined?(@capture_field_timings)
+          @capture_field_timings = !!context.namespace(CONTEXT_NAMESPACE)[TIMINGS_CAPTURE_ENABLED]
         end
 
-        @skip_tracing
-      end
-
-      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
-          self[:lexing_start_time_offset] = nil
-          self[:lexing_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(PreContext.new)
-        @pre_context.value
-      end
-
-      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
+        @capture_field_timings
       end
 
       def capture_lexing_time
-        timed_result = GraphQL::Metrics.time { yield }
-
-        pre_context.lexing_start_time_offset = timed_result.start_time
-        pre_context.lexing_duration = timed_result.duration
-
-        timed_result.result
+        result, duration = GraphQL::Metrics.time { yield }
+        @lexing_duration = duration
+        result
       end
 
       def capture_parsing_time
-        timed_result = GraphQL::Metrics.time { yield }
-
-        pre_context.parsing_start_time_offset = timed_result.start_time
-        pre_context.parsing_duration = timed_result.duration
-
-        timed_result.result
+        result, duration = GraphQL::Metrics.time { yield }
+        @parsing_duration = duration
+        result
       end
 
-      # Also consolidates parsing timings (if any) from the `pre_context`
+      # Also consolidates parsing timings (if any)
       def capture_validation_time(context)
-        # 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 }
+        result, duration = GraphQL::Metrics.time { yield }
 
         ns = context.namespace(CONTEXT_NAMESPACE)
+        ns[LEXING_DURATION] = @lexing_duration
+        ns[PARSING_DURATION] = @parsing_duration
+        ns[VALIDATION_DURATION] = 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
-
-        timed_result.result
+        result
       end
 
       def capture_analysis_time(context)
         ns = context.namespace(CONTEXT_NAMESPACE)
 
-        timed_result = GraphQL::Metrics.time(ns[MULTIPLEX_START_TIME_MONOTONIC]) { yield }
+        result, duration = GraphQL::Metrics.time { yield }
 
-        ns[ANALYSIS_START_TIME_OFFSET] = timed_result.time_since_offset
-        ns[ANALYSIS_DURATION] = timed_result.duration
+        ns[ANALYSIS_DURATION] = duration
 
-        timed_result.result
+        result
       end
 
       def capture_query_start_time(context)
@@ -179,20 +110,13 @@ module GraphQL
 
       def trace_field(context_key, query)
         ns = query.context.namespace(CONTEXT_NAMESPACE)
-        offset_time = ns[GraphQL::Metrics::QUERY_START_TIME_MONOTONIC]
-        start_time = GraphQL::Metrics.current_time_monotonic
         path = query.context[:current_path]
 
-        result = yield
-
-        duration = GraphQL::Metrics.current_time_monotonic - start_time
-        time_since_offset = start_time - offset_time if offset_time
+        result, duration = GraphQL::Metrics.time { yield }
 
         path_excluding_numeric_indicies = path.select { |p| p.is_a?(String) }
         ns[context_key][path_excluding_numeric_indicies] ||= []
-        ns[context_key][path_excluding_numeric_indicies] << {
-          start_time_offset: time_since_offset, duration: duration
-        }
+        ns[context_key][path_excluding_numeric_indicies] << duration
 
         result
       end

data/lib/graphql/metrics/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Metrics
-    VERSION = "5.0.8"
+    VERSION = "6.0.0"
   end
 end

data/lib/graphql/metrics.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "concurrent"
 require "graphql/metrics/version"
 require "graphql/metrics/instrumentation"
 require "graphql/metrics/trace"
-require "graphql/metrics/tracer"
 require "graphql/metrics/analyzer"
 
 module GraphQL
@@ -27,22 +25,13 @@ module GraphQL
     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
 
-    def self.timings_capture_enabled?(context)
-      return false unless context
-      !!context.namespace(CONTEXT_NAMESPACE)[TIMINGS_CAPTURE_ENABLED]
-    end
-
     def self.current_time
       Process.clock_gettime(Process::CLOCK_REALTIME)
     end
@@ -51,40 +40,32 @@ module GraphQL
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
-    def self.time(offset_time = nil)
+    def self.time
       start_time = current_time_monotonic
       result = yield
       duration = current_time_monotonic - start_time
-      time_since_offset = start_time - offset_time if offset_time
-      TimedResult.new(start_time, duration, time_since_offset, result)
+      [result, duration]
     end
 
-    class TimedResult
-      # NOTE: `time_since_offset` is used to produce start times timed phases of execution (validation, field
-      # resolution). These start times are relative to the executed operation's start time, which is captured at the
-      # outset of document parsing.
-      #
-      # The times produced are intentionally similar to:
-      # https://github.com/apollographql/apollo-tracing#response-format
-      #
-      # Taking a field resolver start offset example:
-      #
-      # <   start offset   >
-      # |------------------|----------|--------->
-      # OS (t=0)           FS (t=1)   FE (t=2)
-      #
-      # OS = Operation start time
-      # FS = Field resolver start time
-      # FE = Field resolver end time
-      #
-      attr_reader :result, :start_time, :duration, :time_since_offset
-
-      def initialize(start_time, duration, time_since_offset, result)
-        @start_time = start_time
-        @duration = duration
-        @time_since_offset = time_since_offset
-        @result = result
+    def self.use(
+      schema_defn,
+      analyzer:,
+      tracer: GraphQL::Metrics::Trace,
+      capture_timings: nil,
+      capture_field_timings: nil,
+      trace_mode: :default
+    )
+      if capture_field_timings && !capture_timings
+        raise ArgumentError, "Cannot capture field timings without capturing query timings"
       end
+
+      capture_timings = true if capture_timings.nil?
+      capture_field_timings = true if capture_field_timings.nil?
+      capture_field_timings = false if !capture_timings
+
+      schema_defn.trace_with(GraphQL::Metrics::Instrumentation, capture_field_timings: capture_field_timings)
+      schema_defn.trace_with(tracer, mode: trace_mode) if capture_timings
+      schema_defn.query_analyzer(analyzer)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-metrics
 version: !ruby/object:Gem::Version
-  version: 5.0.8
+  version: 6.0.0
 platform: ruby
 authors:
 - Christopher Butcher
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-06 00:00:00.000000000 Z
+date: 2024-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -16,42 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.12.10
+        version: '2.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.12.10
-- !ruby/object:Gem::Dependency
-  name: concurrent-ruby
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '2.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.2'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -86,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.1.5
+        version: 6.1.7
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.1.5
+        version: 6.1.7
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -201,7 +187,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
 - ".github/workflows/cla.yml"
+- ".github/workflows/dependabot_auto_merge.yml"
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rubocop-http---shopify-github-io-ruby-style-guide-rubocop-yml"
@@ -210,28 +198,27 @@ files:
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - RELEASING
 - Rakefile
 - bin/console
 - bin/setup
-- gemfiles/graphql_1.13.gemfile
-- gemfiles/graphql_2.0.gemfile
+- gemfiles/graphql_2.3.gemfile
 - gemfiles/graphql_head.gemfile
 - graphql_metrics.gemspec
 - lib/graphql/metrics.rb
 - lib/graphql/metrics/analyzer.rb
 - lib/graphql/metrics/instrumentation.rb
 - lib/graphql/metrics/trace.rb
-- lib/graphql/metrics/tracer.rb
 - lib/graphql/metrics/version.rb
 homepage: https://github.com/Shopify/graphql-metrics
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -239,15 +226,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
-signing_key: 
+rubygems_version: 3.5.18
+signing_key:
 specification_version: 4
 summary: GraphQL Metrics Extractor
 test_files: []

data/gemfiles/graphql_2.0.gemfile

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-eval_gemfile("../Gemfile")
-
-gem("graphql", "~> 2.0")

data/lib/graphql/metrics/tracer.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Metrics
-    class Tracer
-      # 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, though old versions of the gem aren't always consistent about this (see
-      # https://github.com/rmosolgo/graphql-ruby/issues/3393). Most of them can be run multiple times when
-      # multiplexing multiple queries.
-      GRAPHQL_GEM_EXECUTE_MULTIPLEX_KEY = 'execute_multiplex' # wraps everything below this line; only run once
-      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_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'
-      ]
-
-      include GraphQL::Metrics::Trace
-
-      def initialize
-        # no-op, but don't want the behavior from GraphQL::Metrics::Trace
-      end
-
-      def trace(key, data, &block)
-        # NOTE: Context doesn't exist yet during lexing, parsing.
-        context = data[:query]&.context
-        skip_tracing = context&.fetch(GraphQL::Metrics::SKIP_GRAPHQL_METRICS_ANALYSIS, false)
-        return yield if skip_tracing
-
-        case key
-        when GRAPHQL_GEM_EXECUTE_MULTIPLEX_KEY
-          return capture_multiplex_start_time(&block)
-        when GRAPHQL_GEM_LEXING_KEY
-          return capture_lexing_time(&block)
-        when GRAPHQL_GEM_PARSING_KEY
-          return capture_parsing_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 context[SKIP_FIELD_AND_ARGUMENT_METRICS]
-          return yield unless GraphQL::Metrics.timings_capture_enabled?(data[:query].context)
-
-          context_key = case key
-          when GRAPHQL_GEM_TRACING_FIELD_KEY
-            GraphQL::Metrics::INLINE_FIELD_TIMINGS
-          when GRAPHQL_GEM_TRACING_LAZY_FIELD_KEY
-            GraphQL::Metrics::LAZY_FIELD_TIMINGS
-          end
-
-          trace_field(context_key, data[:query], &block)
-        else
-          return yield
-        end
-      end
-    end
-  end
-end