appoptics_apm 4.8.3 → 4.11.0

data/lib/appoptics_apm/frameworks/padrino.rb

@@ -38,47 +38,17 @@ module AppOpticsAPM
       end
 
       # TODO add test coverage, currently there are no tests for this
+      # ____ I'm not sure this gets ever called, Padrino uses Sinatra's render method
       def render_with_appoptics(engine, data = nil, options = {}, locals = {}, &block)
         if AppOpticsAPM.tracing?
           report_kvs = {}
 
-          if data
-            report_kvs[:engine] = engine
-            report_kvs[:template] = data
-          else
-            report_kvs[:template] = engine
-          end
-
-          if AppOpticsAPM.tracing_layer_op?(:render)
-            # For recursive calls to :render (for sub-partials and layouts),
-            # use method profiling.
-            begin
-              report_kvs[:FunctionName] = :render
-              report_kvs[:Class]        = :Rendering
-              report_kvs[:Module]       = :Padrino
-              report_kvs[:File]         = __FILE__
-              report_kvs[:LineNumber]   = __LINE__
-            rescue StandardError => e
-              AppOpticsAPM.logger.debug "[appoptics_apm/padrino] #{e.message}"
-              AppOpticsAPM.logger.debug e.backtrace.join(', ')
-            end
-
-            AppOpticsAPM::API.profile(report_kvs[:template], report_kvs, false) do
-              render_without_appoptics(engine, data, options, locals, &block)
-            end
-          else
-            # Fall back to the raw tracing API so we can pass KVs
-            # back on exit (a limitation of the AppOpticsAPM::API.trace
-            # block method) This removes the need for an info
-            # event to send additonal KVs
-            AppOpticsAPM::API.log_entry(:render, {}, :render)
+          report_kvs[:engine] = engine
+          report_kvs[:template] = data
 
-            begin
-              render_without_appoptics(engine, data, options, locals, &block)
-            ensure
-              report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:padrino][:collect_backtraces]
-              AppOpticsAPM::API.log_exit(:render, report_kvs)
-            end
+          AppOpticsAPM::SDK.trace(:padrino_render, report_kvs, :padrino_render) do
+            report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:padrino][:collect_backtraces]
+            render_without_appoptics(engine, data, options, locals, &block)
           end
         else
           render_without_appoptics(engine, data, options, locals, &block)
@@ -88,7 +58,7 @@ module AppOpticsAPM
   end
 end
 
-if defined?(Padrino) && AppopticsAPM::Config[:padrino][:enabled]
+if defined?(Padrino) && AppOpticsAPM::Config[:padrino][:enabled]
   # This instrumentation is a superset of the Sinatra instrumentation similar
   # to how Padrino is a superset of Sinatra itself.
   AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting Padrino' if AppOpticsAPM::Config[:verbose]

data/lib/appoptics_apm/frameworks/rails.rb

@@ -48,7 +48,6 @@ module AppOpticsAPM
       # Load the Rails specific instrumentation
       require 'appoptics_apm/frameworks/rails/inst/action_controller'
       require 'appoptics_apm/frameworks/rails/inst/action_view'
-      require 'appoptics_apm/frameworks/rails/inst/action_view_30'
       require 'appoptics_apm/frameworks/rails/inst/active_record'
       require 'appoptics_apm/frameworks/rails/inst/logger_formatters'
 

data/lib/appoptics_apm/frameworks/rails/inst/action_controller.rb

@@ -35,7 +35,7 @@ module AppOpticsAPM
       #
       # log_rails_error?
       #
-      # Determins whether we should log a raised exception to the
+      # Determines whether we should log a raised exception to the
       # AppOptics dashboard.  This is determined by whether the exception
       # has a rescue handler setup and the value of
       # AppOpticsAPM::Config[:report_rescued_errors]
@@ -84,10 +84,10 @@ module AppOpticsAPM
 end
 
 # ActionController::Base
-if defined?(ActionController::Base) && AppOpticsAPM::Config[:action_controller][:enabled] && Rails::VERSION::MAJOR < 6
+if defined?(ActionController::Base) && AppOpticsAPM::Config[:action_controller][:enabled] && Rails::VERSION::MAJOR <= 6
   AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting actioncontroller' if AppOpticsAPM::Config[:verbose]
   require "appoptics_apm/frameworks/rails/inst/action_controller#{Rails::VERSION::MAJOR}"
-  if Rails::VERSION::MAJOR == 5
+  if Rails::VERSION::MAJOR >= 5
     ActionController::Base.send(:prepend, ::AppOpticsAPM::Inst::ActionController)
   elsif Rails::VERSION::MAJOR < 5
     AppOpticsAPM::Util.send_include(::ActionController::Base, AppOpticsAPM::Inst::ActionController)
@@ -95,7 +95,7 @@ if defined?(ActionController::Base) && AppOpticsAPM::Config[:action_controller][
 end
 
 # ActionController::API - Rails 5 or via the rails-api gem
-if defined?(ActionController::API) && AppOpticsAPM::Config[:action_controller_api][:enabled]  && Rails::VERSION::MAJOR < 6
+if defined?(ActionController::API) && AppOpticsAPM::Config[:action_controller_api][:enabled]  && Rails::VERSION::MAJOR <= 6
   AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting actioncontroller api' if AppOpticsAPM::Config[:verbose]
   require "appoptics_apm/frameworks/rails/inst/action_controller_api"
   ActionController::API.send(:prepend, ::AppOpticsAPM::Inst::ActionControllerAPI)

data/lib/appoptics_apm/frameworks/rails/inst/action_controller6.rb

@@ -0,0 +1,50 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    #
+    # ActionController
+    #
+    # This modules contains the instrumentation code specific
+    # to Rails v6
+    #
+    module ActionController
+      include AppOpticsAPM::Inst::RailsBase
+
+      def process_action(method_name, *args)
+        kvs = {
+            :Controller   => self.class.name,
+            :Action       => self.action_name,
+        }
+        request.env['appoptics_apm.controller'] = kvs[:Controller]
+        request.env['appoptics_apm.action'] = kvs[:Action]
+
+        return super(method_name, *args) unless AppOpticsAPM.tracing?
+        begin
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:action_controller][:collect_backtraces]
+
+          AppOpticsAPM::API.log_entry('rails', kvs)
+          super(method_name, *args)
+
+        rescue Exception => e
+          AppOpticsAPM::API.log_exception('rails', e) if log_rails_error?(e)
+          raise
+        ensure
+          AppOpticsAPM::API.log_exit('rails')
+        end
+      end
+
+      #
+      # render
+      #
+      # Our render wrapper that calls 'trace', which will log if we are tracing
+      #
+      def render(*args, &blk)
+        trace('actionview') do
+          super(*args, &blk)
+        end
+      end
+    end
+  end
+end

data/lib/appoptics_apm/frameworks/rails/inst/action_view.rb

@@ -1,53 +1,40 @@
 # Copyright (c) 2016 SolarWinds, LLC.
 # All rights reserved.
 
-if defined?(ActionView::Base) && AppOpticsAPM::Config[:action_view][:enabled]  && Rails::VERSION::MAJOR < 6
+if defined?(ActionView::Base) && AppOpticsAPM::Config[:action_view][:enabled]
 
-  ##
-  # ActionView Instrumentation is version dependent.  ActionView 2.x is separate
-  # and ActionView 3.0 is a special case.
-  # Everything else goes here. (ActionView 3.1 - 4.0 as of this writing)
-  #
-  if (Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR > 0) || Rails::VERSION::MAJOR >= 4
+  if Rails::VERSION::MAJOR >= 4
 
     AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting actionview' if AppOpticsAPM::Config[:verbose]
 
     ActionView::PartialRenderer.class_eval do
       alias :render_partial_without_appoptics :render_partial
-      def render_partial
+      def render_partial(*args)
         entry_kvs = {}
         begin
-          name = AppOpticsAPM::Util.prettify(@options[:partial]) if @options.is_a?(Hash)
-          entry_kvs[:FunctionName] = :render_partial
-          entry_kvs[:Class]        = :PartialRenderer
-          entry_kvs[:Module]       = :ActionView
-          entry_kvs[:File]         = __FILE__
-          entry_kvs[:LineNumber]   = __LINE__
+          entry_kvs[:Partial] = AppOpticsAPM::Util.prettify(@options[:partial]) if @options.is_a?(Hash)
         rescue => e
           AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
         end
 
-        AppOpticsAPM::API.profile(name, entry_kvs, AppOpticsAPM::Config[:action_view][:collect_backtraces]) do
-          render_partial_without_appoptics
+        AppOpticsAPM::SDK.trace('partial', entry_kvs) do
+          entry_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:action_view][:collect_backtraces]
+          render_partial_without_appoptics(*args)
         end
       end
 
       alias :render_collection_without_appoptics :render_collection
-      def render_collection
+      def render_collection(*args)
         entry_kvs = {}
         begin
-          name = AppOpticsAPM::Util.prettify(@path)
-          entry_kvs[:FunctionName] = :render_collection
-          entry_kvs[:Class]        = :PartialRenderer
-          entry_kvs[:Module]       = :ActionView
-          entry_kvs[:File]         = __FILE__
-          entry_kvs[:LineNumber]   = __LINE__
+          entry_kvs[:Partial] = AppOpticsAPM::Util.prettify(@path)
         rescue => e
           AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
         end
 
-        AppOpticsAPM::API.profile(name, entry_kvs, AppOpticsAPM::Config[:action_view][:collect_backtraces]) do
-          render_collection_without_appoptics
+        AppOpticsAPM::SDK.trace('collection', entry_kvs) do
+          entry_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:action_view][:collect_backtraces]
+          render_collection_without_appoptics(*args)
         end
       end
 

data/lib/appoptics_apm/frameworks/rails/inst/active_record.rb

@@ -5,19 +5,19 @@ require 'appoptics_apm/frameworks/rails/inst/connection_adapters/mysql'
 require 'appoptics_apm/frameworks/rails/inst/connection_adapters/mysql2'
 require 'appoptics_apm/frameworks/rails/inst/connection_adapters/postgresql'
 
-if AppOpticsAPM::Config[:active_record][:enabled] && !defined?(JRUBY_VERSION) && Rails::VERSION::MAJOR < 6
+if AppOpticsAPM::Config[:active_record][:enabled] && !defined?(JRUBY_VERSION) && Rails::VERSION::MAJOR <= 6
   begin
     adapter = ActiveRecord::Base.connection_config[:adapter]
 
     if Rails::VERSION::MAJOR < 5
       require 'appoptics_apm/frameworks/rails/inst/connection_adapters/utils'
-    elsif Rails::VERSION::MAJOR == 5
+    elsif Rails::VERSION::MAJOR >= 5
       require 'appoptics_apm/frameworks/rails/inst/connection_adapters/utils5x'
     end
 
     AppOpticsAPM::Inst::ConnectionAdapters::FlavorInitializers.mysql      if adapter == 'mysql'
     AppOpticsAPM::Inst::ConnectionAdapters::FlavorInitializers.mysql2     if adapter == 'mysql2'
-    AppOpticsAPM::Inst::ConnectionAdapters::FlavorInitializers.postgresql if adapter == 'postgresql'
+    AppOpticsAPM::Inst::ConnectionAdapters::FlavorInitializers.postgresql if adapter =~ /postgresql|postgis/i
 
   rescue StandardError => e
     AppOpticsAPM.logger.error "[appoptics_apm/error] AppOpticsAPM/ActiveRecord error: #{e.inspect}"

data/lib/appoptics_apm/frameworks/rails/inst/connection_adapters/utils.rb

@@ -29,7 +29,7 @@ module AppOpticsAPM
             case adapter_name
             when /mysql/i
               opts[:Flavor] = 'mysql'
-            when /postgres/i
+            when /^postgres|^postgis/i
               opts[:Flavor] = 'postgresql'
             end
           end

data/lib/appoptics_apm/frameworks/rails/inst/connection_adapters/utils5x.rb

@@ -35,7 +35,7 @@ module AppOpticsAPM
               case adapter_name
               when /mysql/i
                 opts[:Flavor] = 'mysql'
-              when /postgres/i
+              when /^postgres|^postgis/i
                 opts[:Flavor] = 'postgresql'
               end
             end

data/lib/appoptics_apm/frameworks/sinatra.rb

@@ -61,38 +61,9 @@ module AppOpticsAPM
           report_kvs[:engine] = engine
           report_kvs[:template] = data
 
-          if AppOpticsAPM.tracing_layer_op?(:render)
-            # For recursive calls to :render (for sub-partials and layouts),
-            # use method profiling.
-            begin
-              name = data
-              report_kvs[:FunctionName] = :render
-              report_kvs[:Class]        = :Templates
-              report_kvs[:Module]       = :'Sinatra::Templates'
-              report_kvs[:File]         = __FILE__
-              report_kvs[:LineNumber]   = __LINE__
-            rescue StandardError => e
-              AppOpticsAPM.logger.debug e.message
-              AppOpticsAPM.logger.debug e.backtrace.join(', ')
-            end
-
-            AppOpticsAPM::API.profile(name, report_kvs, false) do
-              render_without_appoptics(engine, data, options, locals, &block)
-            end
-
-          else
-            # Fall back to the raw tracing API so we can pass KVs
-            # back on exit (a limitation of the AppOpticsAPM::API.trace
-            # block method) This removes the need for an info
-            # event to send additonal KVs
-            AppOpticsAPM::API.log_entry(:render, {}, :render)
-
-            begin
-              render_without_appoptics(engine, data, options, locals, &block)
-            ensure
-              report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:sinatra][:collect_backtraces]
-              AppOpticsAPM::API.log_exit(:render, report_kvs, :render)
-            end
+          AppOpticsAPM::SDK.trace(:sinatra_render, report_kvs, :sinatra_render) do
+            report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:sinatra][:collect_backtraces]
+            render_without_appoptics(engine, data, options, locals, &block)
           end
         else
           render_without_appoptics(engine, data, options, locals, &block)
@@ -102,7 +73,7 @@ module AppOpticsAPM
   end
 end
 
-if defined?(Sinatra) && AppopticsAPM::Config[:sinatra][:enabled]
+if defined?(Sinatra) && AppOpticsAPM::Config[:sinatra][:enabled]
   require 'appoptics_apm/inst/rack'
 
   AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting Sinatra' if AppOpticsAPM::Config[:verbose]

data/lib/appoptics_apm/inst/curb.rb

@@ -46,12 +46,12 @@ module AppOpticsAPM
       end
       
       ##
-      # profile_curb_method
+      # trace_curb_method
       #
       # An agnostic method that will profile any Curl::Easy method (and optional args and block)
       # that you throw at it.
       #
-      def profile_curb_method(kvs, method, args, &block)
+      def trace_curb_method(kvs, method, args, &block)
         # If we're not tracing, just do a fast return.
         unless AppOpticsAPM.tracing?
           unless AppOpticsAPM::API.blacklisted?(URI(url).hostname)
@@ -129,7 +129,7 @@ module AppOpticsAPM
         kvs = {}
         kvs[:HTTPMethod] = :POST
 
-        profile_curb_method(kvs, :http_post_without_appoptics, args, &block)
+        trace_curb_method(kvs, :http_post_without_appoptics, args, &block)
       end
 
       ##
@@ -149,7 +149,7 @@ module AppOpticsAPM
         kvs = {}
         kvs[:HTTPMethod] = :PUT
 
-        profile_curb_method(kvs, :http_put_without_appoptics, args, &block)
+        trace_curb_method(kvs, :http_put_without_appoptics, args, &block)
       end
 
       ##
@@ -178,7 +178,7 @@ module AppOpticsAPM
           kvs[:HTTPMethod] = :GET
         end
 
-        profile_curb_method(kvs, :perform_without_appoptics, nil, &block)
+        trace_curb_method(kvs, :perform_without_appoptics, nil, &block)
       end
 
       ##
@@ -198,7 +198,7 @@ module AppOpticsAPM
         kvs = {}
         kvs[:HTTPMethod] = verb
 
-        profile_curb_method(kvs, :http_without_appoptics, [verb], &block)
+        trace_curb_method(kvs, :http_without_appoptics, [verb], &block)
       end
     end
 

data/lib/appoptics_apm/inst/faraday.rb

@@ -37,7 +37,15 @@ module AppOpticsAPM
             AppOpticsAPM::XTrace.continue_service_context(xtrace, xtrace_new)
           end
           kvs = {}
-          kvs[:Middleware] = @builder.handlers
+
+          # this seems the safer condition than trying to identify the
+          # faraday version when adapter started to work without arg
+          # and handlers don't include the adapter anymore
+          if @builder.method(:adapter).parameters.find { |ele| ele[0] == :req }
+            kvs[:Middleware] = @builder.handlers
+          else
+            kvs[:Middleware] = [@builder.adapter] + @builder.handlers
+          end
           kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:faraday][:collect_backtraces]
 
           # Only send service KVs if we're not using an adapter
@@ -68,16 +76,20 @@ module AppOpticsAPM
 
       # This is only considered a remote service call if the middleware/adapter is not instrumented
       def remote_call?
-        (@builder.handlers.map(&:name) & APPOPTICS_INSTR_ADAPTERS).count == 0
+        if @builder.method(:adapter).parameters.find { |ele| ele[0] == :req }
+          (@builder.handlers.map(&:name) & APPOPTICS_INSTR_ADAPTERS).count == 0
+        else
+          ((@builder.handlers.map(&:name) << @builder.adapter.name) & APPOPTICS_INSTR_ADAPTERS).count == 0
+        end
       end
 
-      def rsc_kvs(url, method, result)
+      def rsc_kvs(_url, method, result)
         kvs = { :Spec => 'rsc',
                 :IsService => 1,
                 :HTTPMethod => method.upcase,
                 :HTTPStatus => result.status, }
         kvs[:Blacklisted] = true if url_blacklisted?
-        kvs[:RemoteURL] = result.to_hash[:url].to_s
+        kvs[:RemoteURL] = result.env.to_hash[:url].to_s
         kvs[:RemoteURL].split('?').first unless AppOpticsAPM::Config[:faraday][:log_args]
 
         kvs

data/lib/appoptics_apm/inst/graphql.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (c) 2019 SolarWinds, LLC.
+# All rights reserved.
+#++
+
+# initial version of this instrumentation:
+# https://github.com/librato/api/blob/master/graph/tracing/appoptics.rb
+#
+
+# TODO: make sure this stays up to date with
+# ____  what is in the graphql gem and vice-versa
+
+
+if defined?(GraphQL::Tracing)
+  module GraphQL
+    module Tracing
+      # AppOpticsTracing in the graphql gem may be a different version than the
+      # one defined here, we want to use the newer one
+      dont_redefine = false
+      this_version = Gem::Version.new('1.0.0')
+
+      if defined?(GraphQL::Tracing::AppOpticsTracing)
+        if this_version > GraphQL::Tracing::AppOpticsTracing.version
+          send(:remove_const, :AppOpticsTracing)
+        else
+          dont_redefine = true
+        end
+      end
+
+      unless dont_redefine
+        #-----------------------------------------------------------------------------#
+        #----- this class is duplicated in the graphql gem ---------------------------#
+        #-----------------------------------------------------------------------------#
+        class AppOpticsTracing < GraphQL::Tracing::PlatformTracing
+          # These GraphQL events will show up as 'graphql.prep' spans
+          PREP_KEYS = ['lex', 'parse', 'validate', 'analyze_query', 'analyze_multiplex'].freeze
+          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 graphql gem, so that the newer
+          # version of the class can be used
+
+          def self.version
+            Gem::Version.new('1.0.0')
+          end
+
+          self.platform_keys = {
+            'lex' => 'lex',
+            'parse' => 'parse',
+            'validate' => 'validate',
+            'analyze_query' => 'analyze_query',
+            'analyze_multiplex' => 'analyze_multiplex',
+            'execute_multiplex' => 'execute_multiplex',
+            'execute_query' => 'execute_query',
+            'execute_query_lazy' => 'execute_query_lazy'
+          }
+
+          def platform_trace(platform_key, _key, data)
+            return yield if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+
+            layer = span_name(platform_key)
+            kvs = metadata(data, layer)
+            kvs[:Key] = platform_key if (PREP_KEYS + EXEC_KEYS).include?(platform_key)
+
+            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
+              yield
+            end
+          end
+
+          def platform_field_key(type, field)
+            "graphql.#{type.name}.#{field.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])
+              else
+                [key, data[key]]
+              end
+            end.flatten.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).flatten.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
+  end
+
+  module AppOpticsAPM
+    module GraphQLSchemaPrepend
+      def use(plugin, options = {})
+        super unless GraphQL::Schema.plugins.find { |pl| pl[0].to_s == plugin.to_s }
+
+        GraphQL::Schema.plugins
+      end
+    end
+
+    # rubocop:disable Style/RedundantSelf
+    module GraphQLErrorPrepend
+      def initialize(*args)
+        super
+        bt = AppOpticsAPM::API.backtrace(1)
+        set_backtrace(bt) unless self.backtrace
+      end
+    end
+    # rubocop:enable Style/RedundantSelf
+  end
+
+  if defined?(GraphQL::Schema)
+    GraphQL::Schema.singleton_class.prepend(AppOpticsAPM::GraphQLSchemaPrepend)
+    GraphQL::Schema.use(GraphQL::Tracing::AppOpticsTracing)
+  end
+
+  # rubocop:disable Style/IfUnlessModifier
+  if defined?(GraphQL::Error)
+    GraphQL::Error.prepend(AppOpticsAPM::GraphQLErrorPrepend)
+  end
+  # rubocop:enable Style/IfUnlessModifier
+end