appoptics_apm 4.2.3 → 4.2.4

data/lib/appoptics_apm/api/metrics.rb

@@ -7,28 +7,42 @@ module  AppOpticsAPM
       # it checks if it can send metrics with the current transaction name
       # or a default transaction name and sets the transaction name accordingly
       #
-      # === Arguments
+      # === Arguments:
       #
       # * +span+ the name of the current span (used to construct a transaction name if none is defined)
       # * +kvs+ A hash containing key/value pairs, only the value of :TransactionName will be relevant
       #
-      # Returns the result of the block.
+      # === Returns:
+      # The result of the block.
       #
+      # === Assigns:
+      # The transaction_name to kvs[:TransactionName]
 
-      def send_metrics(span, kvs = {})
-        # This is a new span, we do not know the transaction name yet
-        AppOpticsAPM.transaction_name = nil
-
-        # if a transaction name is provided it will take precedence over transaction names defined
-        # later or in lower spans
+      def send_metrics(span, kvs)
         start = Time.now
-
         yield
       ensure
         duration =(1000 * 1000 * (Time.now - start)).round(0)
-        transaction_name = AppOpticsAPM::API.determine_transaction_name(span, kvs)
-        kvs[:TransactionName] = AppOpticsAPM::API.set_transaction_name(AppOpticsAPM::Span.createSpan(transaction_name, nil, duration))
+        transaction_name = determine_transaction_name(span)
+        kvs[:TransactionName] = AppOpticsAPM::Span.createSpan(transaction_name, nil, duration)
+        AppOpticsAPM.transaction_name = nil
+      end
+
+      private
+
+      ##
+      # Determine the transaction name to be set on the trace
+      #
+      # === Argument:
+      # * +opts+ (hash) the value of :TransactionName will be set as custom transaction name
+      #
+      # === Returns:
+      # (string) the current transaction name
+      #
+      def determine_transaction_name(span)
+        AppOpticsAPM.transaction_name || AppOpticsAPM::SDK.set_transaction_name("custom-#{span}")
       end
+
     end
   end
 end

data/lib/appoptics_apm/api/profiling.rb

@@ -88,14 +88,13 @@ module AppOpticsAPM
         if !klass.is_a?(Module)
           AppOpticsAPM.logger.warn "[appoptics_apm/error] profile_method: Not sure what to do with #{klass}.  Send a class or module."
           return false
+        end
 
+        if method.is_a?(String)
+          method = method.to_sym
         elsif !method.is_a?(Symbol)
-          if method.is_a?(String)
-            method = method.to_sym
-          else
-            AppOpticsAPM.logger.warn "[appoptics_apm/error] profile_method: Not sure what to do with #{method}.  Send a string or symbol for method."
-            return false
-          end
+          AppOpticsAPM.logger.warn "[appoptics_apm/error] profile_method: Not sure what to do with #{method}.  Send a string or symbol for method."
+          return false
         end
 
         instance_method = klass.instance_methods.include?(method) || klass.private_instance_methods.include?(method)
@@ -177,11 +176,7 @@ module AppOpticsAPM
         report_kvs[:Language] ||= :ruby
         report_kvs[:ProfileName] ||= opts[:name] ? opts[:name] : method
 
-        if klass.is_a?(Class)
-          report_kvs[:Class] = klass.to_s
-        else
-          report_kvs[:Module] = klass.to_s
-        end
+        klass.is_a?(Class) ? report_kvs[:Class] = klass.to_s : report_kvs[:Module] = klass.to_s
 
         # If this is a Rails Controller, report the KVs
         if defined?(::AbstractController::Base) && klass.ancestors.include?(::AbstractController::Base)

data/lib/appoptics_apm/api/tracing.rb

@@ -44,32 +44,11 @@ module AppOpticsAPM
       #
       # Returns an array with the result of the block and the last xtrace used
       def start_trace(span, xtrace = nil, opts = {})
-        return [yield, nil] unless AppOpticsAPM.loaded
-
-        # if it is not an entry span!
-        return [trace(span, opts) { yield }, AppopticsAPM::Context.toString] if AppOpticsAPM::Context.isValid
-
-        log_start(span, xtrace, opts)
-
-        # send_metrics deals with the logic for setting AppOpticsAPM.transaction_name
-        # and ensures that metrics are sent
-        # log_end sets the transaction_name
-        result = send_metrics(span, opts) do
-          begin
-            yield
-          rescue Exception => e # rescue everything ok, since we are raising
-            AppOpticsAPM::API.log_exception(span, e)
-            e.instance_variable_set(:@xtrace, log_end(span))
-            raise
-          end
-        end
-        xtrace = AppopticsAPM::Context.toString
-        log_end(span, opts)
-
-        [result, xtrace]
+        target = {}
+        [start_trace_with_target(span, xtrace, target, opts) { yield }, target['X-Trace']]
       end
 
 
     end
   end
-end
+end

data/lib/appoptics_apm/base.rb

@@ -99,6 +99,7 @@ module AppOpticsAPMBase
   ##
   # pickup_context
   #
+  # for JRUBY
   # Determines whether we should pickup context
   # from an incoming X-Trace request header.  The answer
   # is generally yes but there are cases in JRuby under
@@ -134,17 +135,16 @@ module AppOpticsAPMBase
   # operation being traced.  This is used in cases of recursive
   # operation tracing or one instrumented operation calling another.
   #
-  # <operation> can be a single symbol or an array of symbols that
-  # will be checked against.
-  #
   # In such cases, we only want to trace the outermost operation.
   #
   def tracing_layer_op?(operation)
-    if operation.is_a?(Array)
-      operation.include?(AppOpticsAPM.layer_op)
-    else
-      AppOpticsAPM.layer_op == operation.to_sym
+    unless AppOpticsAPM.layer_op.nil? || AppOpticsAPM.layer_op.is_a?(Array)
+      AppOpticsAPM.logger.error('[appopticsapm/logging] INTERNAL: layer_op should be nil or an array, please report to support@appoptics.com')
+      return false
     end
+
+    return false if AppOpticsAPM.layer_op.nil? || AppOpticsAPM.layer_op.empty? || !operation.respond_to?(:to_sym)
+    AppOpticsAPM.layer_op.last == operation.to_sym
   end
 
   ##
@@ -190,31 +190,6 @@ module AppOpticsAPMBase
     end
   end
 
-  ##
-  # Debugging helper method
-  #
-  def pry!
-    # Only valid for development or test environments
-    env = ENV['RACK_ENV'] || ENV['RAILS_ENV']
-    return unless %w(development, test).include? env
-
-    require 'pry'
-    require 'pry-byebug'
-
-    if defined?(PryByebug)
-      Pry.commands.alias_command 'c', 'continue'
-      Pry.commands.alias_command 's', 'step'
-      Pry.commands.alias_command 'n', 'next'
-      Pry.commands.alias_command 'f', 'finish'
-
-      Pry::Commands.command(/^$/, 'repeat last command') do
-        _pry_.run_command Pry.history.to_a.last
-      end
-    end
-
-    byebug
-  end
-
   ##
   # Indicates whether a supported framework is in use
   # or not

data/lib/appoptics_apm/config.rb

@@ -57,13 +57,31 @@ module AppOpticsAPM
       config_file = File.join(Dir.pwd, 'appoptics_apm_config.rb')
       config_files << config_file if File.exist?(config_file)
 
-      return if config_files.empty?
+      return if config_files.empty?  # we use the defaults from the template in this case
 
       if config_files.size > 1
         $stderr.puts 'Found multiple configuration files, using the first one listed:'
         config_files.each { |path| $stderr.puts "  #{path}" }
       end
       load(config_files[0])
+      check_env_vars
+    end
+
+    # There are 4 variables that can be set in the config file or as env vars.
+    # Oboe will override vars passed in if it finds an environment variable
+    # :debug_level and :verbose need special consideration, because they are used in Ruby
+    def self.check_env_vars
+      unless (0..6).include?(AppOpticsAPM::Config[:debug_level])
+        AppOpticsAPM::Config[:debug_level] = nil
+      end
+      # let's use the same debug level for ruby as well
+      debug_level = ENV['APPOPTICS_DEBUG_LEVEL'] || AppOpticsAPM::Config[:debug_level] || 3
+      AppOpticsAPM.logger.level = [4 - debug_level.to_i, 0].max
+
+      # the verbose setting is only relevant for ruby, ENV['APPOPTICS_GEM_VERBOSE'] overrides
+      if ENV.key?('APPOPTICS_GEM_VERBOSE')
+        AppOpticsAPM::Config[:verbose] = ENV['APPOPTICS_GEM_VERBOSE'].downcase == 'true'
+      end
     end
 
     ##
@@ -109,12 +127,16 @@ module AppOpticsAPM
     #
     # rubocop:disable Metrics/AbcSize
     def self.initialize(_data = {})
-      @@instrumentation.each do |k|
-        @@config[k] = {}
-      end
+      @@instrumentation.each { |k| @@config[k] = {} }
       @@config[:transaction_name] = {}
+
+      # Always load the template, it has all the keys and defaults defined,
+      # no guarantee of completeness in the user's config file
       load(File.join(File.dirname(File.dirname(__FILE__)),
                     'rails/generators/appoptics_apm/templates/appoptics_apm_initializer.rb'))
+
+      # to make sure we include the service_key if it is set as an ENV var
+      check_env_vars
     end
     # rubocop:enable Metrics/AbcSize
 

data/lib/appoptics_apm/frameworks/grape.rb

@@ -1,5 +1,7 @@
 # Copyright (c) 2016 SolarWinds, LLC.
 # All rights reserved.
+#
+class GrapeError < StandardError; end
 
 module AppOpticsAPM
   module Grape
@@ -26,7 +28,8 @@ module AppOpticsAPM
 
         report_kvs[:Controller] = options[:for].name
         if route && route.pattern
-          report_kvs[:Action] = route.pattern.origin
+          report_kvs[:Action] = route.options ? "#{route.options[:method]}#{route.pattern.origin}" : route.pattern.origin
+          # report_kvs[:Action] = route.pattern.origin
         else
           report_kvs[:Action] = args.empty? ? env['PATH_INFO'] : args[0]['PATH_INFO']
         end
@@ -54,13 +57,12 @@ module AppOpticsAPM
           xtrace = AppOpticsAPM::Context.toString
 
           if AppOpticsAPM.tracing?
-            # Since Grape uses throw/catch and not Exceptions, we manually log
-            # the error here.
-            kvs = {}
-            kvs[:ErrorClass] = 'GrapeError'
-            kvs[:ErrorMsg] = error[:message] ? error[:message] : "No message given."
-            kvs[:Backtrace] = ::AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:grape][:collect_backtraces]
-            ::AppOpticsAPM::API.log('rack', 'error', kvs)
+
+            # Since Grape uses throw/catch and not Exceptions, we have to create an exception here
+            exception = GrapeError.new(error[:message] ? error[:message] : "No message given.")
+            exception.set_backtrace(::AppOpticsAPM::API.backtrace) if AppOpticsAPM::Config[:grape][:collect_backtraces]
+
+            ::AppOpticsAPM::API.log_exception('rack', exception )
 
             # Since calls to error() are handled similar to abort in Grape.  We
             # manually log the rack exit here since the original code won't

data/lib/appoptics_apm/frameworks/padrino.rb

@@ -23,6 +23,9 @@ module AppOpticsAPM
         env['appoptics_apm.action']     = report_kvs[:Action]
 
         result
+      rescue => e
+        ::AppOpticsAPM::API.log_exception('padrino', e)
+        raise e
       ensure
         ::AppOpticsAPM::API.log_exit('padrino', report_kvs)
       end

data/lib/appoptics_apm/frameworks/rails.rb

@@ -6,12 +6,15 @@ module AppOpticsAPM
     module Helpers
       extend ActiveSupport::Concern if defined?(::Rails) and ::Rails::VERSION::MAJOR > 2
 
+      # Deprecated
+      # no usages
       def appoptics_rum_header
         AppOpticsAPM.logger.warn '[appoptics_apm/warn] Note that appoptics_rum_header is deprecated.  It is now a no-op and should be removed from your application code.'
         return ''
       end
       alias_method :oboe_rum_header, :appoptics_rum_header
 
+      # Deprecated
       def appoptics_rum_footer
         AppOpticsAPM.logger.warn '[appoptics_apm/warn] Note that appoptics_rum_footer is deprecated.  It is now a no-op and should be removed from your application code.'
         return ''
@@ -33,10 +36,8 @@ module AppOpticsAPM
       #
       if File.exist?("#{rails_root}/config/initializers/tracelytics.rb")
         tr_initializer = "#{rails_root}/config/initializers/tracelytics.rb"
-
       elsif File.exist?("#{rails_root}/config/initializers/oboe.rb")
         tr_initializer = "#{rails_root}/config/initializers/oboe.rb"
-
       else
         tr_initializer = "#{rails_root}/config/initializers/appoptics_apm.rb"
       end
@@ -47,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_2x'
       require 'appoptics_apm/frameworks/rails/inst/action_view_30'
       require 'appoptics_apm/frameworks/rails/inst/active_record'
 
@@ -59,12 +59,8 @@ module AppOpticsAPM
       # ActiveSupport.on_load(:action_controller) do
       #   include AppOpticsAPM::Rails::Helpers
       # end
-      if ::Rails::VERSION::MAJOR > 2
-        ActiveSupport.on_load(:action_view) do
-          include AppOpticsAPM::Rails::Helpers
-        end
-      else
-        ActionView::Base.send :include, AppOpticsAPM::Rails::Helpers
+      ActiveSupport.on_load(:action_view) do
+        include AppOpticsAPM::Rails::Helpers
       end
     end
   end # Rails
@@ -73,44 +69,26 @@ end # AppOpticsAPM
 if defined?(::Rails)
   require 'appoptics_apm/inst/rack'
 
-  if ::Rails::VERSION::MAJOR > 2
-    module AppOpticsAPM
-      class Railtie < ::Rails::Railtie
-        initializer 'appoptics_apm.helpers' do
-          AppOpticsAPM::Rails.include_helpers
-        end
-
-        initializer 'appoptics_apm.rack' do |app|
-          AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting rack' if AppOpticsAPM::Config[:verbose]
-          app.config.middleware.insert 0, AppOpticsAPM::Rack
-        end
-
-        config.after_initialize do
-          AppOpticsAPM.logger = ::Rails.logger if ::Rails.logger && !ENV.key?('APPOPTICS_GEM_TEST')
-
-          AppOpticsAPM::Inst.load_instrumentation
-          AppOpticsAPM::Rails.load_instrumentation
-
-          # Report __Init after fork when in Heroku
-          AppOpticsAPM::API.report_init unless AppOpticsAPM.heroku?
-        end
+  module AppOpticsAPM
+    class Railtie < ::Rails::Railtie
+      initializer 'appoptics_apm.helpers' do
+        AppOpticsAPM::Rails.include_helpers
       end
-    end
-  else
-    AppOpticsAPM.logger = ::Rails.logger if ::Rails.logger
 
-    AppOpticsAPM::Rails.load_initializer
+      initializer 'appoptics_apm.rack' do |app|
+        AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting rack' if AppOpticsAPM::Config[:verbose]
+        app.config.middleware.insert 0, AppOpticsAPM::Rack
+      end
 
-    Rails.configuration.after_initialize do
-      AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting rack' if AppOpticsAPM::Config[:verbose]
-      Rails.configuration.middleware.insert 0, 'AppOpticsAPM::Rack'
+      config.after_initialize do
+        AppOpticsAPM.logger = ::Rails.logger if ::Rails.logger && !ENV.key?('APPOPTICS_GEM_TEST')
 
-      AppOpticsAPM::Inst.load_instrumentation
-      AppOpticsAPM::Rails.load_instrumentation
-      AppOpticsAPM::Rails.include_helpers
+        AppOpticsAPM::Inst.load_instrumentation
+        AppOpticsAPM::Rails.load_instrumentation
 
-      # Report __Init after fork when in Heroku
-      AppOpticsAPM::API.report_init unless AppOpticsAPM.heroku?
+        # Report __Init after fork when in Heroku
+        AppOpticsAPM::API.report_init unless AppOpticsAPM.heroku?
+      end
     end
   end
 end

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

@@ -43,20 +43,18 @@ module AppOpticsAPM
       def log_rails_error?(exception)
         # As it's perculating up through the layers...  make sure that
         # we only report it once.
-        return false if exception.instance_variable_get(:@appoptics_logged)
+        return false if exception.instance_variable_get(:@exn_logged)
 
-        has_handler = has_handler?(exception)
+        return false if has_handler?(exception) && !AppOpticsAPM::Config[:report_rescued_errors]
 
-        if !has_handler || (has_handler && AppOpticsAPM::Config[:report_rescued_errors])
-          return true
-        end
-        false
+        true
       end
 
       ##
       # This method does the logging if we are tracing
       # it `wraps` around the call to the original method
       #
+      # This can't use the SDK trace() method because of the log_rails_error?(e) condition
       def trace(layer)
         return yield unless AppOpticsAPM.tracing?
         begin

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

@@ -36,7 +36,7 @@ module AppOpticsAPM
           process_action_without_appoptics(method_name, *args)
 
         rescue Exception => e
-          AppOpticsAPM::API.log_exception(nil, e) if log_rails_error?(e)
+          AppOpticsAPM::API.log_exception('rails', e) if log_rails_error?(e)
           raise
         ensure
           AppOpticsAPM::API.log_exit('rails')

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

@@ -28,7 +28,7 @@ module AppOpticsAPM
           super(method_name, *args)
 
         rescue Exception => e
-          AppOpticsAPM::API.log_exception(nil, e) if log_rails_error?(e)
+          AppOpticsAPM::API.log_exception('rails', e) if log_rails_error?(e)
           raise
         ensure
           AppOpticsAPM::API.log_exit('rails')

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

@@ -28,7 +28,7 @@ module AppOpticsAPM
           super(method_name, *args)
 
         rescue Exception => e
-          AppOpticsAPM::API.log_exception(nil, e) if log_rails_error?(e)
+          AppOpticsAPM::API.log_exception('rails', e) if log_rails_error?(e)
           raise
         ensure
           AppOpticsAPM::API.log_exit('rails-api')