graphql 1.13.24 → 2.5.11

data/lib/graphql/tracing/appoptics_trace.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require "graphql/tracing/platform_trace"
+
+module GraphQL
+  module Tracing
+
+    # This class uses the AppopticsAPM SDK from the appoptics_apm gem to create
+    # traces for GraphQL.
+    #
+    # There are 4 configurations available. They can be set in the
+    # appoptics_apm config file or in code. Please see:
+    # {https://docs.appoptics.com/kb/apm_tracing/ruby/configure}
+    #
+    #     AppOpticsAPM::Config[:graphql][:enabled] = true|false
+    #     AppOpticsAPM::Config[:graphql][:transaction_name]  = true|false
+    #     AppOpticsAPM::Config[:graphql][:sanitize_query] = true|false
+    #     AppOpticsAPM::Config[:graphql][:remove_comments] = true|false
+    module AppOpticsTrace
+      # These GraphQL events will show up as 'graphql.prep' spans
+      PREP_KEYS = ['lex', 'parse', 'validate', 'analyze_query', 'analyze_multiplex'].freeze
+      # These GraphQL events will show up as 'graphql.execute' spans
+      EXEC_KEYS = ['execute_multiplex', 'execute_query', 'execute_query_lazy'].freeze
+
+
+      # During auto-instrumentation this version of AppOpticsTracing is compared
+      # with the version provided in the appoptics_apm gem, so that the newer
+      # version of the class can be used
+
+
+      def self.version
+        Gem::Version.new('1.0.0')
+      end
+
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
+      [
+        'lex',
+        'parse',
+        'validate',
+        'analyze_query',
+        'analyze_multiplex',
+        'execute_multiplex',
+        'execute_query',
+        'execute_query_lazy',
+      ].each do |trace_method|
+        module_eval <<-RUBY, __FILE__, __LINE__
+          def #{trace_method}(**data)
+            return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+            layer = span_name("#{trace_method}")
+            kvs = metadata(data, layer)
+            kvs[:Key] = "#{trace_method}" if (PREP_KEYS + EXEC_KEYS).include?("#{trace_method}")
+
+            transaction_name(kvs[:InboundQuery]) if kvs[:InboundQuery] && layer == 'graphql.execute'
+
+            ::AppOpticsAPM::SDK.trace(layer, kvs) do
+              kvs.clear # we don't have to send them twice
+              super
+            end
+          end
+        RUBY
+      end
+
+      # rubocop:enable Development/NoEvalCop
+
+      def execute_field(query:, field:, ast_node:, arguments:, object:)
+        return_type = field.type.unwrap
+        trace_field = if return_type.kind.scalar? || return_type.kind.enum?
+          (field.trace.nil? && @trace_scalars) || field.trace
+        else
+          true
+        end
+        platform_key = if trace_field
+          @platform_key_cache[AppOpticsTrace].platform_field_key_cache[field]
+        else
+          nil
+        end
+        if platform_key && trace_field
+          return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+          layer = platform_key
+          kvs = metadata({query: query, field: field, ast_node: ast_node, arguments: arguments, object: object}, layer)
+
+          ::AppOpticsAPM::SDK.trace(layer, kvs) do
+            kvs.clear # we don't have to send them twice
+            super
+          end
+        else
+          super
+        end
+      end
+
+      def execute_field_lazy(query:, field:, ast_node:, arguments:, object:)  # rubocop:disable Development/TraceCallsSuperCop
+        execute_field(query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
+      end
+
+      def authorized(**data)
+        return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+        layer = @platform_key_cache[AppOpticsTrace].platform_authorized_key_cache[data[:type]]
+        kvs = metadata(data, layer)
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          super
+        end
+      end
+
+      def authorized_lazy(**data)
+        return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+        layer = @platform_key_cache[AppOpticsTrace].platform_authorized_key_cache[data[:type]]
+        kvs = metadata(data, layer)
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          super
+        end
+      end
+
+      def resolve_type(**data)
+        return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+        layer = @platform_key_cache[AppOpticsTrace].platform_resolve_type_key_cache[data[:type]]
+
+        kvs = metadata(data, layer)
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          super
+        end
+      end
+
+      def resolve_type_lazy(**data)
+        return super if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+        layer = @platform_key_cache[AppOpticsTrace].platform_resolve_type_key_cache[data[:type]]
+        kvs = metadata(data, layer)
+
+        ::AppOpticsAPM::SDK.trace(layer, kvs) do
+          kvs.clear # we don't have to send them twice
+          super
+        end
+      end
+
+      include PlatformTrace
+
+      def platform_field_key(field)
+        "graphql.#{field.owner.graphql_name}.#{field.graphql_name}"
+      end
+
+      def platform_authorized_key(type)
+        "graphql.authorized.#{type.graphql_name}"
+      end
+
+      def platform_resolve_type_key(type)
+        "graphql.resolve_type.#{type.graphql_name}"
+      end
+
+      private
+
+      def gql_config
+        ::AppOpticsAPM::Config[:graphql] ||= {}
+      end
+
+      def transaction_name(query)
+        return if gql_config[:transaction_name] == false ||
+          ::AppOpticsAPM::SDK.get_transaction_name
+
+        split_query = query.strip.split(/\W+/, 3)
+        split_query[0] = 'query' if split_query[0].empty?
+        name = "graphql.#{split_query[0..1].join('.')}"
+
+        ::AppOpticsAPM::SDK.set_transaction_name(name)
+      end
+
+      def multiplex_transaction_name(names)
+        return if gql_config[:transaction_name] == false ||
+          ::AppOpticsAPM::SDK.get_transaction_name
+
+        name = "graphql.multiplex.#{names.join('.')}"
+        name = "#{name[0..251]}..." if name.length > 254
+
+        ::AppOpticsAPM::SDK.set_transaction_name(name)
+      end
+
+      def span_name(key)
+        return 'graphql.prep' if PREP_KEYS.include?(key)
+        return 'graphql.execute' if EXEC_KEYS.include?(key)
+
+        key[/^graphql\./] ? key : "graphql.#{key}"
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def metadata(data, layer)
+        data.keys.map do |key|
+          case key
+          when :context
+            graphql_context(data[key], layer)
+          when :query
+            graphql_query(data[key])
+          when :query_string
+            graphql_query_string(data[key])
+          when :multiplex
+            graphql_multiplex(data[key])
+          when :path
+            [key, data[key].join(".")]
+          else
+            [key, data[key]]
+          end
+        end.tap { _1.flatten!(2) }.each_slice(2).to_h.merge(Spec: 'graphql')
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def graphql_context(context, layer)
+        context.errors && context.errors.each do |err|
+          AppOpticsAPM::API.log_exception(layer, err)
+        end
+
+        [[:Path, context.path.join('.')]]
+      end
+
+      def graphql_query(query)
+        return [] unless query
+
+        query_string = query.query_string
+        query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
+        query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
+
+        [[:InboundQuery, query_string],
+         [:Operation, query.selected_operation_name]]
+      end
+
+      def graphql_query_string(query_string)
+        query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
+        query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
+
+        [:InboundQuery, query_string]
+      end
+
+      def graphql_multiplex(data)
+        names = data.queries.map(&:operations).map!(&:keys).tap(&:flatten!).tap(&:compact!)
+        multiplex_transaction_name(names) if names.size > 1
+
+        [:Operations, names.join(', ')]
+      end
+
+      def sanitize(query)
+        return unless query
+
+        # remove arguments
+        query.gsub(/"[^"]*"/, '"?"')                 # strings
+          .gsub(/-?[0-9]*\.?[0-9]+e?[0-9]*/, '?') # ints + floats
+          .gsub(/\[[^\]]*\]/, '[?]')              # arrays
+      end
+
+      def remove_comments(query)
+        return unless query
+
+        query.gsub(/#[^\n\r]*/, '')
+      end
+    end
+  end
+end

data/lib/graphql/tracing/appoptics_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
 
@@ -20,6 +22,11 @@ module GraphQL
       # These GraphQL events will show up as 'graphql.execute' spans
       EXEC_KEYS = ['execute_multiplex', 'execute_query', 'execute_query_lazy'].freeze
 
+      def initialize(...)
+        warn "GraphQL::Tracing::AppOptics tracing is deprecated; update to SolarWindsAPM instead, which uses OpenTelemetry."
+        super
+      end
+
       # During auto-instrumentation this version of AppOpticsTracing is compared
       # with the version provided in the appoptics_apm gem, so that the newer
       # version of the class can be used
@@ -117,7 +124,7 @@ module GraphQL
           else
             [key, data[key]]
           end
-        end.flatten(2).each_slice(2).to_h.merge(Spec: 'graphql')
+        end.tap { _1.flatten!(2) }.each_slice(2).to_h.merge(Spec: 'graphql')
       end
       # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
@@ -148,7 +155,7 @@ module GraphQL
       end
 
       def graphql_multiplex(data)
-        names = data.queries.map(&:operations).map(&:keys).flatten.compact
+        names = data.queries.map(&:operations).map!(&:keys).tap(&:flatten!).tap(&:compact!)
         multiplex_transaction_name(names) if names.size > 1
 
         [:Operations, names.join(', ')]

data/lib/graphql/tracing/appsignal_trace.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+require "graphql/tracing/monitor_trace"
+
+module GraphQL
+  module Tracing
+    # Instrumentation for reporting GraphQL-Ruby times to Appsignal.
+    #
+    # @example Installing the tracer
+    #   class MySchema < GraphQL::Schema
+    #     trace_with GraphQL::Tracing::AppsignalTrace
+    #   end
+    AppsignalTrace = MonitorTrace.create_module("appsignal")
+    module AppsignalTrace
+      # @param set_action_name [Boolean] If true, the GraphQL operation name will be used as the transaction name.
+      #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
+      #   It can also be specified per-query with `context[:set_appsignal_action_name]`.
+      def initialize(set_action_name: false, **rest)
+        rest[:set_transaction_name] ||= set_action_name
+        setup_appsignal_monitor(**rest)
+        super
+      end
+
+      class AppsignalMonitor < MonitorTrace::Monitor
+        def instrument(keyword, object)
+          if keyword == :execute
+            query = object.queries.first
+            set_this_txn_name =  query.context[:set_appsignal_action_name]
+            if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
+              Appsignal::Transaction.current.set_action(transaction_name(query))
+            end
+          end
+          Appsignal.instrument(name_for(keyword, object)) do
+            yield
+          end
+        end
+
+        include MonitorTrace::Monitor::GraphQLSuffixNames
+        class Event < GraphQL::Tracing::MonitorTrace::Monitor::Event
+          def start
+            Appsignal::Transaction.current.start_event
+          end
+
+          def finish
+            Appsignal::Transaction.current.finish_event(
+              @monitor.name_for(@keyword, @object),
+              "",
+              ""
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/appsignal_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
     class AppsignalTracing < PlatformTracing

data/lib/graphql/tracing/call_legacy_tracers.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    # This trace class calls legacy-style tracer with payload hashes.
+    # New-style `trace_with` modules significantly reduce the overhead of tracing,
+    # but that advantage is lost when legacy-style tracers are also used (since the payload hashes are still constructed).
+    module CallLegacyTracers
+      def lex(query_string:)
+        (@multiplex || @query).trace("lex", { query_string: query_string }) { super }
+      end
+
+      def parse(query_string:)
+        (@multiplex || @query).trace("parse", { query_string: query_string }) { super }
+      end
+
+      def validate(query:, validate:)
+        query.trace("validate", { validate: validate, query: query }) { super }
+      end
+
+      def analyze_multiplex(multiplex:)
+        multiplex.trace("analyze_multiplex", { multiplex: multiplex }) { super }
+      end
+
+      def analyze_query(query:)
+        query.trace("analyze_query", { query: query }) { super }
+      end
+
+      def execute_multiplex(multiplex:)
+        multiplex.trace("execute_multiplex", { multiplex: multiplex }) { super }
+      end
+
+      def execute_query(query:)
+        query.trace("execute_query", { query: query }) { super }
+      end
+
+      def execute_query_lazy(query:, multiplex:)
+        multiplex.trace("execute_query_lazy", { multiplex: multiplex, query: query }) { super }
+      end
+
+      def execute_field(field:, query:, ast_node:, arguments:, object:)
+        query.trace("execute_field", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
+        query.trace("execute_field_lazy", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
+      end
+
+      def authorized(query:, type:, object:)
+        query.trace("authorized", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def authorized_lazy(query:, type:, object:)
+        query.trace("authorized_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def resolve_type(query:, type:, object:)
+        query.trace("resolve_type", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def resolve_type_lazy(query:, type:, object:)
+        query.trace("resolve_type_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+    end
+  end
+end

data/lib/graphql/tracing/data_dog_trace.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+require "graphql/tracing/monitor_trace"
+
+module GraphQL
+  module Tracing
+    # A tracer for reporting to DataDog
+    # @example Adding this tracer to your schema
+    #   class MySchema < GraphQL::Schema
+    #     trace_with GraphQL::Tracing::DataDogTrace
+    #   end
+    # @example Skipping `resolve_type` and `authorized` events
+    #   trace_with GraphQL::Tracing::DataDogTrace, trace_authorized: false, trace_resolve_type: false
+    DataDogTrace = MonitorTrace.create_module("datadog")
+    module DataDogTrace
+      class DatadogMonitor < MonitorTrace::Monitor
+        def initialize(set_transaction_name:, service: nil, tracer: nil, **_rest)
+          super
+          if tracer.nil?
+            tracer = defined?(Datadog::Tracing) ? Datadog::Tracing : Datadog.tracer
+          end
+          @tracer = tracer
+          @service_name = service
+          @has_prepare_span = @trace.respond_to?(:prepare_span)
+        end
+
+        attr_reader :tracer, :service_name
+
+        def instrument(keyword, object)
+          trace_key = name_for(keyword, object)
+          @tracer.trace(trace_key, service: @service_name, type: 'custom') do |span|
+            span.set_tag('component', 'graphql')
+            op_name = keyword.respond_to?(:name) ? keyword.name : keyword.to_s
+            span.set_tag('operation', op_name)
+
+            if keyword == :execute
+              operations = object.queries.map(&:selected_operation_name).join(', ')
+              first_query = object.queries.first
+              resource = if operations.empty?
+                fallback_transaction_name(first_query && first_query.context)
+              else
+                operations
+              end
+              span.resource = resource if resource
+
+              span.set_tag("selected_operation_name", first_query.selected_operation_name)
+              span.set_tag("selected_operation_type", first_query.selected_operation&.operation_type)
+              span.set_tag("query_string", first_query.query_string)
+            end
+
+            if @has_prepare_span
+              @trace.prepare_span(keyword, object, span)
+            end
+            yield
+          end
+        end
+
+        include MonitorTrace::Monitor::GraphQLSuffixNames
+        class Event < MonitorTrace::Monitor::Event
+          def start
+            name = @monitor.name_for(keyword, object)
+            @dd_span = @monitor.tracer.trace(name, service: @monitor.service_name, type: 'custom')
+          end
+
+          def finish
+            @dd_span.finish
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
     class DataDogTracing < PlatformTracing
@@ -66,6 +68,7 @@ module GraphQL
       end
 
       def analytics_sample_rate
+        # [Deprecated] options[:analytics_sample_rate] will be removed in the future
         options.fetch(:analytics_sample_rate, 1.0)
       end
 

data/lib/graphql/tracing/detailed_trace/memory_backend.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class DetailedTrace
+      # An in-memory trace storage backend. Suitable for testing and development only.
+      # It won't work for multi-process deployments and everything is erased when the app is restarted.
+      class MemoryBackend
+        def initialize(limit: nil)
+          @limit = limit
+          @traces = {}
+          @next_id = 0
+        end
+
+        def traces(last:, before:)
+          page = []
+          @traces.values.reverse_each do |trace|
+            if page.size == last
+              break
+            elsif before.nil? || trace.begin_ms < before
+              page << trace
+            end
+          end
+          page
+        end
+
+        def find_trace(id)
+          @traces[id]
+        end
+
+        def delete_trace(id)
+          @traces.delete(id.to_i)
+          nil
+        end
+
+        def delete_all_traces
+          @traces.clear
+          nil
+        end
+
+        def save_trace(operation_name, duration, begin_ms, trace_data)
+          id = @next_id
+          @next_id += 1
+          @traces[id] = DetailedTrace::StoredTrace.new(
+            id: id,
+            operation_name: operation_name,
+            duration_ms: duration,
+            begin_ms: begin_ms,
+            trace_data: trace_data
+          )
+          if @limit && @traces.size > @limit
+            del_keys = @traces.keys[0...-@limit]
+            del_keys.each { |k| @traces.delete(k) }
+          end
+          id
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/detailed_trace/redis_backend.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class DetailedTrace
+      class RedisBackend
+        KEY_PREFIX = "gql:trace:"
+        def initialize(redis:, limit: nil)
+          @redis = redis
+          @key = KEY_PREFIX + "traces"
+          @remrangebyrank_limit = limit ? -limit - 1 : nil
+        end
+
+        def traces(last:, before:)
+          before = case before
+          when Numeric
+            "(#{before}"
+          when nil
+            "+inf"
+          end
+          str_pairs = @redis.zrange(@key, before, 0, byscore: true, rev: true, limit: [0, last || 100], withscores: true)
+          str_pairs.map do |(str_data, score)|
+            entry_to_trace(score, str_data)
+          end
+        end
+
+        def delete_trace(id)
+          @redis.zremrangebyscore(@key, id, id)
+          nil
+        end
+
+        def delete_all_traces
+          @redis.del(@key)
+        end
+
+        def find_trace(id)
+          str_data = @redis.zrange(@key, id, id, byscore: true).first
+          if str_data.nil?
+            nil
+          else
+            entry_to_trace(id, str_data)
+          end
+        end
+
+        def save_trace(operation_name, duration_ms, begin_ms, trace_data)
+          id = begin_ms
+          data = JSON.dump({ "o" => operation_name, "d" => duration_ms, "b" => begin_ms, "t" => Base64.encode64(trace_data) })
+          @redis.pipelined do |pipeline|
+            pipeline.zadd(@key, id, data)
+            if @remrangebyrank_limit
+              pipeline.zremrangebyrank(@key, 0, @remrangebyrank_limit)
+            end
+          end
+          id
+        end
+
+        private
+
+        def entry_to_trace(id, json_str)
+          data = JSON.parse(json_str)
+          StoredTrace.new(
+            id: id,
+            operation_name: data["o"],
+            duration_ms: data["d"].to_f,
+            begin_ms: data["b"].to_i,
+            trace_data: Base64.decode64(data["t"]),
+          )
+        end
+      end
+    end
+  end
+end