graphql-metrics 2.0.1 → 3.0.0

data/lib/graphql_metrics/instrumentation.rb

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

data/lib/graphql_metrics/timed_batch_executor.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQLMetrics
-  BASE_CLASS = if defined?(GraphQL::Batch::Executor)
-    GraphQL::Batch::Executor
-  else
-    class NoExecutor
-      class << self
-        def resolve(_loader)
-          super
-        end
-
-        def around_promise_callbacks
-          super
-        end
-      end
-    end
-
-    NoExecutor
-  end
-
-  class TimedBatchExecutor < BASE_CLASS
-    TIMINGS = {}
-    private_constant :TIMINGS
-
-    class << self
-      def timings
-        TIMINGS
-      end
-
-      def clear_timings
-        TIMINGS.clear
-      end
-
-      def serialize_loader_key(loader_key)
-        identifiers = []
-
-        serialized = loader_key.map do |group_arg|
-          if [Class, Symbol, String].include?(group_arg.class)
-            group_arg
-          elsif group_arg.is_a?(Numeric)
-            identifiers << group_arg
-            '_'
-          elsif group_arg.respond_to?(:id)
-            identifiers << group_arg.id
-            "#{group_arg.class}/_"
-          else
-            '?'
-          end
-        end
-
-        [serialized.map(&:to_s).join('/'), identifiers.map(&:to_s)]
-      end
-    end
-
-    def resolve(loader)
-      @resolve_meta = {
-        start_time: Instrumentation.current_time,
-        current_loader: loader,
-        perform_queue_sizes: loader.send(:queue).size
-      }
-
-      super
-    end
-
-    def around_promise_callbacks
-      return super unless @resolve_meta
-
-      end_time = Instrumentation.current_time
-
-      TIMINGS[@resolve_meta[:current_loader].loader_key] ||= { times: [], perform_queue_sizes: [] }
-      TIMINGS[@resolve_meta[:current_loader].loader_key][:times] << end_time - @resolve_meta[:start_time]
-      TIMINGS[@resolve_meta[:current_loader].loader_key][:perform_queue_sizes] << @resolve_meta[:perform_queue_sizes]
-
-      @resolve_meta = nil
-
-      super
-    end
-  end
-end

data/lib/graphql_metrics/version.rb

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