graphql-metrics 5.0.3 → 5.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abf17ff04ff0eb71cd30861aeec84ea3fd53fe561affccdf375343fc7b8897b3
-  data.tar.gz: 4297bb879eff66d756dded5a8e588e26bd65b4cf23d041208a465f979dc9a9f0
+  metadata.gz: 7422838e228e2f0dd82382ee2b165b7ab7dfee2b5430044d5b8e2e3f83da173a
+  data.tar.gz: 934f63e77e19731fa2f675185d92d81c30b9087a747cfddc7798986327b85a8c
 SHA512:
-  metadata.gz: d6cff213c42b23297591abc236fbfe411c82f3e48456b7d9fa94063dbe422a06c95ab2145611d8ef5750e4a280024d80e61eb1bfb0203617168fee916d8c3eec
-  data.tar.gz: 119101eac9cd8210b1713917bb45ad371ac1390b21249af677b8b4347c4e585668b4f5b49b029227130a2abc4a88985c6ec592e2e0c214f22866ec7204700f75
+  metadata.gz: 16f4f5ed3f00779216232748c5ad45e248b90b8827568d6f323e3a9477e61e273f67e66893bb439494d3e88526b8aec84a7fe1d35691b283235687cecacdbf58
+  data.tar.gz: c69155471bc5c372903af17d8311b0a6f95c55df7f8e490436217ffbfb0c4472401567375ed097bc11b93aa4cd1276f3d64a7d09e6d3e41254efc0fbed0a1156

data/.github/workflows/ruby.yml

@@ -7,7 +7,7 @@ jobs:
       matrix:
         os: [ubuntu-latest]
         ruby: ['2.7', '3.0', '3.1', '3.2']
-        gemfile: ['graphql_1.13', 'graphql_2.0']
+        gemfile: ['graphql_1.13', 'graphql_2.0', 'graphql_head']
     runs-on: ${{ matrix.os }}
     env:
       BUNDLE_GEMFILE: ${{ github.workspace }}/gemfiles/${{ matrix.gemfile }}.gemfile

data/CHANGELOG.md

@@ -1,5 +1,9 @@
+5.0.4
+-----
+- [71](https://github.com/Shopify/graphql-metrics/pull/71) Fix handling of inline fragment without a parent type.
+
 5.0.3
-=====
+-----
 - [69](https://github.com/Shopify/graphql-metrics/pull/69) Loosen concurrent-ruby dependency
 
 5.0.2

data/gemfiles/graphql_head.gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+eval_gemfile("../Gemfile")
+
+gem("graphql", github: "rmosolgo/graphql-ruby", branch: "master")

data/lib/graphql/metrics/analyzer.rb

@@ -175,7 +175,7 @@ module GraphQL
         when GraphQL::Language::Nodes::OperationDefinition
           parent.operation_type
         when GraphQL::Language::Nodes::InlineFragment
-          parent.type.name
+          parent&.type&.name
         else
           parent.name
         end

data/lib/graphql/metrics/trace.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Metrics
+    module Trace
+      def initialize(**_rest)
+        super
+        context = (@multiplex || @query).context
+        @skip_tracing = context&.fetch(GraphQL::Metrics::SKIP_GRAPHQL_METRICS_ANALYSIS, false)
+      end
+
+      # NOTE: These methods 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.
+
+      # wraps everything below this line; only run once
+      def execute_multiplex(multiplex:, &block)
+        return yield if @skip_tracing
+        capture_multiplex_start_time(&block)
+
+      end
+
+      # may not trigger if the query is passed in pre-parsed
+      def lex(query_string:, &block)
+        return yield if @skip_tracing
+        capture_lexing_time(&block)
+      end
+
+      # may not trigger if the query is passed in pre-parsed
+      def parse(query_string:, &block)
+        return yield if @skip_tracing
+        capture_parsing_time(&block)
+      end
+
+      def validate(query:, validate:, &block)
+        return yield if @skip_tracing
+        capture_validation_time(query.context, &block)
+      end
+
+      # wraps all `analyze_query`s; only run once
+      def analyze_multiplex(multiplex:, &block)
+        return yield if @skip_tracing
+        # 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
+        yield
+      end
+
+      def analyze_query(query:, &block)
+        return yield if @skip_tracing
+        capture_analysis_time(query.context, &block)
+      end
+
+      def execute_query(query:, &block)
+        return yield if @skip_tracing
+        capture_query_start_time(query.context, &block)
+      end
+
+      def execute_field(field:, query:, ast_node:, arguments:, object:, &block)
+        return yield if @skip_tracing || query.context[SKIP_FIELD_AND_ARGUMENT_METRICS]
+        return yield unless GraphQL::Metrics.timings_capture_enabled?(query.context)
+        trace_field(GraphQL::Metrics::INLINE_FIELD_TIMINGS, query, &block)
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:, &block)
+        return yield if @skip_tracing || query.context[SKIP_FIELD_AND_ARGUMENT_METRICS]
+        return yield unless GraphQL::Metrics.timings_capture_enabled?(query.context)
+        trace_field(GraphQL::Metrics::LAZY_FIELD_TIMINGS, query, &block)
+      end
+
+      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
+          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
+      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
+      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
+      end
+
+      # Also consolidates parsing timings (if any) from the `pre_context`
+      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 }
+
+        ns = context.namespace(CONTEXT_NAMESPACE)
+
+        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
+      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, query)
+        ns = query.context.namespace(CONTEXT_NAMESPACE)
+        offset_time = ns[GraphQL::Metrics::QUERY_START_TIME_MONOTONIC]
+        start_time = GraphQL::Metrics.current_time_monotonic
+
+        result = yield
+
+        duration = GraphQL::Metrics.current_time_monotonic - start_time
+        time_since_offset = start_time - offset_time if offset_time
+
+        path_excluding_numeric_indicies = query.context[:current_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
+        }
+
+        result
+      end
+    end
+  end
+end

data/lib/graphql/metrics/tracer.rb

@@ -19,6 +19,12 @@ module GraphQL
         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
@@ -54,130 +60,11 @@ module GraphQL
             GraphQL::Metrics::LAZY_FIELD_TIMINGS
           end
 
-          trace_field(context_key, data, &block)
+          trace_field(context_key, data[:query], &block)
         else
           return yield
         end
       end
-
-      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
-          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
-      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
-      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
-      end
-
-      # Also consolidates parsing timings (if any) from the `pre_context`
-      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 }
-
-        ns = context.namespace(CONTEXT_NAMESPACE)
-
-        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
-      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)
-        offset_time = ns[GraphQL::Metrics::QUERY_START_TIME_MONOTONIC]
-        start_time = GraphQL::Metrics.current_time_monotonic
-
-        result = yield
-
-        duration = GraphQL::Metrics.current_time_monotonic - start_time
-        time_since_offset = start_time - offset_time if offset_time
-
-        path_excluding_numeric_indicies = data[: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
-        }
-
-        result
-      end
     end
   end
 end

data/lib/graphql/metrics/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Metrics
-    VERSION = "5.0.3"
+    VERSION = "5.0.4"
   end
 end

data/lib/graphql/metrics.rb

@@ -3,6 +3,7 @@
 require "concurrent"
 require "graphql/metrics/version"
 require "graphql/metrics/instrumentation"
+require "graphql/metrics/trace"
 require "graphql/metrics/tracer"
 require "graphql/metrics/analyzer"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-metrics
 version: !ruby/object:Gem::Version
-  version: 5.0.3
+  version: 5.0.4
 platform: ruby
 authors:
 - Christopher Butcher
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-06 00:00:00.000000000 Z
+date: 2023-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -218,10 +218,12 @@ files:
 - bin/setup
 - gemfiles/graphql_1.13.gemfile
 - gemfiles/graphql_2.0.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