gem 'graphql-metrics'

require 'graphql/metrics'

gem 'graphql-metrics', require: 'graphql/metrics'

  class SimpleAnalyzer < GraphQL::Metrics::Analyzer
    ANALYZER_NAMESPACE = :simple_analyzer_namespace

    def initialize(query_or_multiplex)
      super

      # `query` is defined on instances of objects inheriting from GraphQL::Metrics::Analyzer
      ns = query.context.namespace(ANALYZER_NAMESPACE)
      ns[:simple_extractor_results] = {}
    end

    # @param metrics [Hash] Query metrics, including a few details about the query document itself, as well as runtime
    # timings metrics, intended to be compatible with the Apollo Tracing spec:
    # https://github.com/apollographql/apollo-tracing#response-format
    #
    # {
    #   operation_type: "query",
    #   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
    # manually capture from `query` and/or `query.context`.
    def query_extracted(metrics)
      custom_metrics_from_context = {
        request_id: query.context[:request_id],
        # ...
      }

      # You can make use of captured metrics here (logging to Kafka, request logging etc.)
      # log_metrics(:fields, metrics)
      #
      # Or store them on the query context:
      store_metrics(:queries, metrics.merge(custom_metrics_from_context))
    end

    # For use after controller:
    # class GraphQLController < ActionController::Base
    #   def graphql_query
    #     query_result = graphql_query.result.to_h
    #     do_something_with_metrics(query.context[:simple_extractor_results])
    #     render json: graphql_query.result
    #   end
    # end

    # @param metrics [Hash] Field selection metrics, including resolver timings metrics, also adhering to the Apollo
    # Tracing spec referred to above.
    #
    # `resolver_timings` is populated any time a field is resolved (which may be many times, if the field is nested
    # within a list field e.g. a Relay connection field).
    #
    # `lazy_resolver_timings` is only populated by fields that are resolved lazily (for example using the
    # graphql-batch gem) or that are otherwise resolved with a Promise. Any time spent in the field's resolver to
    # prepare work to be done "later" in a Promise, or batch loader will be captured in `resolver_timings`. The time
    # spent actually doing lazy field loading, including time spent within a batch loader can be obtained from
    # `lazy_resolver_timings`.
    #
    # {
    #   field_name: "id",
    #   return_type_name: "ID",
    #   parent_type_name: "Post",
    #   deprecated: false,
    #   path: ["post", "id"],
    #   resolver_timings: [
    #     start_time_offset: 0.011901999998372048,
    #     duration: 5.999987479299307e-06
    #   ],
    #   lazy_resolver_timings: [
    #     start_time_offset: 0.031901999998372048,
    #     duration: 5.999987479299307e-06
    #   ],
    # }
    def field_extracted(metrics)
      store_metrics(:fields, metrics)
    end

    # @param metrics [Hash] Directive metrics
    # {
    #   directive_name: "customDirective",
    # }
    def directive_extracted(metrics)
      store_metrics(:directives, metrics)
    end

    # @param metrics [Hash] Argument usage metrics, including a few details about the query document itself, as well
    # as resolver timings metrics, also ahering to the Apollo Tracing spec referred to above.
    # {
    #   argument_name: "ids",
    #   argument_type_name: "ID",
    #   parent_name: "comments",
    #   grandparent_type_name: "Post",
    #   grandparent_node_name: "post",
    #   default_used: false,
    #   value_is_null: false,
    #   value: <GraphQL::Query::Arguments::ArgumentValue>,
    # }
    #
    # `value` is exposed here, in case you want to get access to the argument's definition, including the type
    # class which defines it, e.g. `metrics[:value].definition.metadata[:type_class]`
    def argument_extracted(metrics)
      store_metrics(:arguments, metrics)
    end

    private

    def store_metrics(context_key, metrics)
      ns = query.context.namespace(ANALYZER_NAMESPACE)
      ns[:simple_extractor_results][context_key] ||= []
      ns[:simple_extractor_results][context_key] << metrics
    end
  end

{
  argument_name: "if",                    # argument name
  argument_type_name: "Boolean",          # argument type
  parent_name: "skip",                    # argument belongs to `skip` directive
  grandparent_type_name: "__Directive",   # argument was applied to directive
  grandparent_node_name: "title",         # directive was applied to field title
  default_used: false,                    # check if default value was used
  value_is_null: false,                   # check if value was null
  value: <GraphQL::Execution::Interpreter::ArgumentValue>
}, {
  argument_name: "id",
  argument_name: "ids",
  argument_type_name: "ID",
  parent_name: "comments",                # name of the node that argument was applied to
  grandparent_type_name: "Post",          # grandparent node to uniquely identify which node the argument was applied to
  grandparent_node_name: "post",          # name of grandparend node
  default_used: false,
  value_is_null: false,
  value: <GraphQL::Execution::Interpreter::ArgumentValue>
}, {
  argument_name: "id",
  argument_type_name: "ID",
  parent_name: "post",                   # argument applied to post field
  grandparent_type_name: "QueryRoot",    # post is a QueryRoot
  grandparent_node_name: "query",        # post field is already in the query root
  parent_input_object_type: nil,
  default_used: false,
  value_is_null: false,
  value: <GraphQL::Execution::Interpreter::ArgumentValue>
}, {
  argument_name: "val",
  argument_type_name: "Int",
  parent_name: "customDirective",        # argument belongs to `customDirective` directive
  grandparent_type_name: "__Directive",  # argument was applied to directive
  grandparent_node_name: "query",        # directive was applied to query
  parent_input_object_type: nil,
  default_used: false,
  value_is_null: false,
  value: <GraphQL::Execution::Interpreter::ArgumentValue>
}

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/.
end

class Schema < GraphQL::Schema
  query QueryRoot
  mutation MutationRoot

  query_analyzer SimpleAnalyzer
end