appoptics_apm 4.8.2 → 4.10.1

data/lib/appoptics_apm.rb

@@ -43,12 +43,11 @@ begin
 
   # appoptics_apm/loading can set AppOpticsAPM.loaded = false if the service key is not working
   require 'appoptics_apm/loading'
-  require 'appoptics_apm/legacy_method_profiling'
-  require 'appoptics_apm/method_profiling'
 
   if AppOpticsAPM.loaded
     require 'appoptics_apm/instrumentation'
     require 'appoptics_apm/support/transaction_metrics'
+    require 'appoptics_apm/support/x_trace_options'
 
     # Frameworks
     require 'appoptics_apm/frameworks/rails'
@@ -68,7 +67,6 @@ begin
   # Load Ruby module last.  If there is no framework detected,
   # it will load all of the Ruby instrumentation
   require 'appoptics_apm/ruby'
-  require 'oboe/backward_compatibility'
 
   require 'appoptics_apm/test' if ENV['APPOPTICS_GEM_TEST']
 rescue => e

data/lib/appoptics_apm/api.rb

@@ -6,7 +6,6 @@ module AppOpticsAPM
   module API
     extend AppOpticsAPM::API::Logging
     extend AppOpticsAPM::API::Metrics
-    extend AppOpticsAPM::API::Profiling
     extend AppOpticsAPM::API::LayerInit
     extend AppOpticsAPM::API::Util
 

data/lib/appoptics_apm/api/tracing.rb

@@ -48,6 +48,10 @@ module AppOpticsAPM
         [start_trace_with_target(span, xtrace, target, opts) { yield }, target['X-Trace']]
       end
 
+      def profile_method(*args)
+        AppOpticsAPM.logger.warn("DEPRECATED: AppOpticsAPM::API.profile_method is deprecated. Use: AppOpticsAPM::SDK::trace_method")
+        AppOpticsAPM::SDK.trace_method(*args)
+      end
     end
   end
 end

data/lib/appoptics_apm/config.rb

@@ -16,13 +16,20 @@ module AppOpticsAPM
     @@instrumentation = [:action_controller, :action_controller_api, :action_view,
                          :active_record, :bunnyclient, :bunnyconsumer, :cassandra, :curb,
                          :dalli, :delayed_jobclient, :delayed_jobworker,
-                         :em_http_request, :excon, :faraday, :grpc_client, :grpc_server, :grape,
+                         :excon, :faraday, :grpc_client, :grpc_server, :grape,
                          :httpclient, :nethttp, :memcached, :mongo, :moped, :padrino, :rack, :redis,
                          :resqueclient, :resqueworker, :rest_client,
                          :sequel, :sidekiqclient, :sidekiqworker, :sinatra, :typhoeus]
 
+    # ignore configs for instrumentations we don't have anymore
+    # can't remove because the config may still be present in configs created
+    # with previous gem versions
+    @@ignore = [:em_http_request]
+
     # Subgrouping of instrumentation
-    @@http_clients = [:curb, :excon, :em_http_request, :faraday, :httpclient, :nethttp, :rest_client, :typhoeus]
+    @@http_clients = [:curb, :excon,
+                      # :em_http_request,
+                      :faraday, :httpclient, :nethttp, :rest_client, :typhoeus]
 
     ##
     # load_config_file
@@ -136,7 +143,7 @@ module AppOpticsAPM
     #
     # rubocop:disable Metrics/AbcSize
     def self.initialize(_data = {})
-      @@instrumentation.each { |k| @@config[k] = {} }
+      (@@instrumentation+@@ignore).each { |k| @@config[k] = {} }
       @@config[:transaction_name] = {}
 
       # Always load the template, it has all the keys and defaults defined,
@@ -240,11 +247,15 @@ module AppOpticsAPM
         end
 
       elsif key == :tracing_mode
-      #   CAN'T DO THIS ANYMORE, ALL TRACING COMMUNICATION TO OBOE
+      #   CAN'T DO `set_tracing_mode` ANYMORE, ALL TRACING COMMUNICATION TO OBOE
       #   IS NOW HANDLED BY TransactionSettings
       #   AppOpticsAPM.set_tracing_mode(value.to_sym) if AppOpticsAPM.loaded
 
-      # Make sure that the mode is stored as a symbol
+        # Make sure that the mode is stored as a symbol
+        @@config[key.to_sym] = value.to_sym
+
+      elsif key == :trigger_tracing_mode
+        # Make sure that the mode is stored as a symbol
         @@config[key.to_sym] = value.to_sym
       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)

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,18 +84,18 @@ module AppOpticsAPM
 end
 
 # ActionController::Base
-if defined?(ActionController::Base) && AppOpticsAPM::Config[:action_controller][:enabled]
+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
     ActionController::Base.send(:prepend, ::AppOpticsAPM::Inst::ActionController)
-  else
+  elsif Rails::VERSION::MAJOR < 5
     AppOpticsAPM::Util.send_include(::ActionController::Base, AppOpticsAPM::Inst::ActionController)
   end
 end
 
-# ActionController::API - Rails 5+ or via the rails-api gem
-if defined?(ActionController::API) && AppOpticsAPM::Config[:action_controller_api][:enabled]
+# ActionController::API - Rails 5 or via the rails-api gem
+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

@@ -3,51 +3,38 @@
 
 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)
+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'
-    else
+    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)

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