appoptics_apm 4.8.4 → 4.11.1

data/lib/appoptics_apm/frameworks/grape.rb

@@ -53,7 +53,8 @@ module AppOpticsAPM
         end
 
         def error_response_with_appoptics(error = {})
-          status, headers, body = error_response_without_appoptics(error)
+          response = error_response_without_appoptics(error)
+          status, headers, _body = response.finish
 
           xtrace = AppOpticsAPM::Context.toString
 
@@ -77,7 +78,7 @@ module AppOpticsAPM
             end
           end
 
-          [status, headers, body]
+          response
         end
       end
     end

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]

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

@@ -17,7 +17,7 @@ if AppOpticsAPM::Config[:active_record][:enabled] && !defined?(JRUBY_VERSION) &&
 
     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,240 @@
+# 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) && !(AppOpticsAPM::Config[:graphql][:enabled] == false)
+  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
+      redefine = true
+      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
+          redefine = false
+        end
+      end
+
+      if 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 }
+        super unless self.plugins.find { |pl| pl[0].to_s == plugin.to_s }
+
+        self.plugins
+      end
+
+      def inherited(subclass)
+        subclass.use(GraphQL::Tracing::AppOpticsTracing)
+        super
+      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
+
+    # a different way of autoinstrumenting for graphql 1.7.4 - < 1.8.0
+    module GraphQLSchemaPrepend17
+      def initialize
+        super
+        unless tracers.find { |tr| tr.is_a? GraphQL::Tracing::AppOpticsTracing }
+          tracer = GraphQL::Tracing::AppOpticsTracing.new
+          tracers.push(tracer)
+          instrumenters[:field] << tracer
+        end
+      end
+    end
+  end
+
+  if Gem.loaded_specs['graphql'] && Gem.loaded_specs['graphql'].version >= Gem::Version.new('1.8.0')
+    AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting GraphQL' if AppOpticsAPM::Config[:verbose]
+    if defined?(GraphQL::Schema)
+      GraphQL::Schema.singleton_class.prepend(AppOpticsAPM::GraphQLSchemaPrepend)
+    end
+
+    # rubocop:disable Style/IfUnlessModifier
+    if defined?(GraphQL::Error)
+      GraphQL::Error.prepend(AppOpticsAPM::GraphQLErrorPrepend)
+    end
+    # rubocop:enable Style/IfUnlessModifier
+  elsif Gem.loaded_specs['graphql'] && Gem.loaded_specs['graphql'].version >= Gem::Version.new('1.7.4')
+    AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting GraphQL' if AppOpticsAPM::Config[:verbose]
+    if defined?(GraphQL::Schema)
+      GraphQL::Schema.prepend(AppOpticsAPM::GraphQLSchemaPrepend17)
+    end
+  end
+end