appoptics_apm_mnfst 4.5.2

data/lib/appoptics_apm/frameworks/grape.rb

@@ -0,0 +1,97 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+#
+class GrapeError < StandardError; end
+
+module AppOpticsAPM
+  module Grape
+    module API
+      def self.extended(klass)
+        AppOpticsAPM::Util.class_method_alias(klass, :inherited, ::Grape::API)
+      end
+
+      def inherited_with_appoptics(subclass)
+        inherited_without_appoptics(subclass)
+
+        subclass.use AppOpticsAPM::Rack
+      end
+    end
+
+    module Endpoint
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :run, ::Grape::Endpoint)
+      end
+
+      def run_with_appoptics(*args)
+        # Report Controller/Action and Transaction as best possible
+        report_kvs = {}
+
+        report_kvs[:Controller] = options[:for].to_s
+        report_kvs[:Action] =
+          if route&.pattern
+            route.options ? "#{route.options[:method]}#{route.pattern.origin}" : route.pattern.origin
+          else
+            args.empty? ? env['PATH_INFO'] : args[0]['PATH_INFO']
+          end
+        report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:grape][:collect_backtraces]
+
+        env['appoptics_apm.controller'] = report_kvs[:Controller]
+        env['appoptics_apm.action']     = report_kvs[:Action]
+
+        AppOpticsAPM::API.log_entry('grape', report_kvs)
+
+        run_without_appoptics(*args)
+      ensure
+        AppOpticsAPM::API.log_exit('grape')
+      end
+    end
+
+    module Middleware
+      module Error
+        def self.included(klass)
+          AppOpticsAPM::Util.method_alias(klass, :error_response, ::Grape::Middleware::Error)
+        end
+
+        def error_response_with_appoptics(error = {})
+          status, headers, body = error_response_without_appoptics(error)
+
+          xtrace = AppOpticsAPM::Context.toString
+
+          if AppOpticsAPM.tracing?
+
+            # 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)
+
+            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
+            # be returned to
+            xtrace = AppOpticsAPM::API.log_end('rack', :Status => status)
+          end
+
+          if headers && AppOpticsAPM::XTrace.valid?(xtrace)
+            unless defined?(JRUBY_VERSION) && AppOpticsAPM.is_continued_trace?
+              headers['X-Trace'] = xtrace if headers.is_a?(Hash)
+            end
+          end
+
+          [status, headers, body]
+        end
+      end
+    end
+  end
+end
+
+if AppOpticsAPM::Config[:grape][:enabled] && defined?(Grape)
+  require 'appoptics_apm/inst/rack'
+
+  AppOpticsAPM.logger.info "[appoptics_apm/loading] Instrumenting Grape" if AppOpticsAPM::Config[:verbose]
+
+  AppOpticsAPM::Inst.load_instrumentation
+
+  AppOpticsAPM::Util.send_extend(Grape::API,                AppOpticsAPM::Grape::API)
+  AppOpticsAPM::Util.send_include(Grape::Endpoint,          AppOpticsAPM::Grape::Endpoint)
+  AppOpticsAPM::Util.send_include(Grape::Middleware::Error, AppOpticsAPM::Grape::Middleware::Error)
+end

data/lib/appoptics_apm/frameworks/padrino.rb

@@ -0,0 +1,108 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module PadrinoInst
+    module Routing
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :dispatch!, ::Padrino::Routing)
+      end
+
+      def dispatch_with_appoptics
+
+        AppOpticsAPM::API.log_entry('padrino', {})
+        report_kvs = {}
+
+        result = dispatch_without_appoptics
+
+        # Report Controller/Action and Transaction as best possible
+        controller = (request.controller && !request.controller.empty?) ? request.controller : nil
+        report_kvs[:Controller] = controller || self.class
+        report_kvs[:Action] = request.route_obj ? request.route_obj.path : request.action
+        env['appoptics_apm.controller'] = report_kvs[:Controller]
+        env['appoptics_apm.action']     = report_kvs[:Action]
+
+        result
+      rescue => e
+        AppOpticsAPM::API.log_exception('padrino', e)
+        raise e
+      ensure
+        report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:padrino][:collect_backtraces]
+        AppOpticsAPM::API.log_exit('padrino', report_kvs)
+      end
+    end
+
+    module Rendering
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :render, ::Padrino::Rendering)
+      end
+
+      # TODO add test coverage, currently there are no tests for this
+      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)
+
+            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
+          end
+        else
+          render_without_appoptics(engine, data, options, locals, &block)
+        end
+      end
+    end
+  end
+end
+
+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]
+
+  Padrino.after_load do
+    AppOpticsAPM.logger = Padrino.logger if Padrino.respond_to?(:logger)
+    AppOpticsAPM::Inst.load_instrumentation
+
+    AppOpticsAPM::Util.send_include(Padrino::Routing::InstanceMethods, AppOpticsAPM::PadrinoInst::Routing)
+    if defined?(Padrino::Rendering)
+      AppOpticsAPM::Util.send_include(Padrino::Rendering::InstanceMethods, AppOpticsAPM::PadrinoInst::Rendering)
+    end
+
+    # Report __Init after fork when in Heroku
+    AppOpticsAPM::API.report_init unless AppOpticsAPM.heroku?
+  end
+end

data/lib/appoptics_apm/frameworks/rails.rb

@@ -0,0 +1,94 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Rails
+    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 ''
+      end
+      alias_method :oboe_rum_footer, :appoptics_rum_footer
+    end # Helpers
+
+    def self.load_initializer
+      # Force load the AppOpticsAPM Rails initializer if there is one
+      # Prefer appoptics_apm.rb but give priority to the legacy tracelytics.rb if it exists
+      if ::Rails::VERSION::MAJOR > 2
+        rails_root = ::Rails.root.to_s
+      else
+        rails_root = RAILS_ROOT.to_s
+      end
+
+      #
+      # We've been through 3 initializer names.  Try each one.
+      #
+      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
+      require tr_initializer if File.exist?(tr_initializer)
+    end
+
+    def self.load_instrumentation
+      # 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'
+
+      AppOpticsAPM.logger.info "[appoptics_apm/rails] AppOpticsAPM gem #{AppOpticsAPM::Version::STRING} successfully loaded."
+    end
+
+    def self.include_helpers
+      # TBD: This would make the helpers available to controllers which is occasionally desired.
+      # ActiveSupport.on_load(:action_controller) do
+      #   include AppOpticsAPM::Rails::Helpers
+      # end
+      ActiveSupport.on_load(:action_view) do
+        include AppOpticsAPM::Rails::Helpers
+      end
+    end
+  end # Rails
+end # AppOpticsAPM
+
+if defined?(::Rails)
+  require 'appoptics_apm/inst/rack'
+
+  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
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    #
+    # RailsBase
+    #
+    # This module contains the instrumentation code common to
+    # many Rails versions.
+    #
+    module RailsBase
+
+      #
+      # has_handler?
+      #
+      # Determins if <tt>exception</tt> has a registered
+      # handler via <tt>rescue_from</tt>
+      #
+      def has_handler?(exception)
+        # Don't log exceptions if they have a rescue handler set
+        has_handler = false
+        rescue_handlers.detect do |klass_name, _handler|
+          # Rescue handlers can be specified as strings or constant names
+          klass = self.class.const_get(klass_name) rescue nil
+          klass ||= klass_name.constantize rescue nil
+          has_handler = exception.is_a?(klass) if klass
+        end
+        has_handler
+      rescue => e
+        AppOpticsAPM.logger.debug "[appoptics_apm/debug] Error searching Rails handlers: #{e.message}"
+        return false
+      end
+
+      #
+      # log_rails_error?
+      #
+      # Determins 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]
+      #
+      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(:@exn_logged)
+
+        return false if has_handler?(exception) && !AppOpticsAPM::Config[:report_rescued_errors]
+
+        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
+          AppOpticsAPM::API.log_entry(layer)
+          yield
+        rescue Exception => e
+          AppOpticsAPM::API.log_exception(layer, e) if log_rails_error?(e)
+          raise
+        ensure
+          AppOpticsAPM::API.log_exit(layer)
+        end
+      end
+
+
+      #
+      # render_with_appoptics
+      #
+      # Our render wrapper that calls 'add_logging', which will log if we are tracing
+      #
+      def render_with_appoptics(*args, &blk)
+        trace('actionview') do
+          render_without_appoptics(*args, &blk)
+        end
+      end
+    end
+  end
+end
+
+# ActionController::Base
+if defined?(ActionController::Base) && AppOpticsAPM::Config[:action_controller][:enabled]
+  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
+    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]
+  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)
+end
+
+# vim:set expandtab:tabstop=2

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

@@ -0,0 +1,55 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    #
+    # ActionController
+    #
+    # This modules contains the instrumentation code specific
+    # to Rails v3
+    #
+    module ActionController
+      include AppOpticsAPM::Inst::RailsBase
+
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :process, :appoptics
+          alias_method_chain :process_action, :appoptics
+          alias_method_chain :render, :appoptics
+        end
+      end
+
+      def process_with_appoptics(*args)
+        request.env['appoptics_apm.controller'] = self.class.name
+        request.env['appoptics_apm.action'] = self.action_name
+
+        trace('rails') do
+          process_without_appoptics(*args)
+        end
+      end
+
+      def process_action_with_appoptics(*args)
+        kvs = {
+            :Controller   => self.class.name,
+            :Action       => action_name,
+        }
+        request.env['appoptics_apm.controller'] = kvs[:Controller]
+        request.env['appoptics_apm.action'] = kvs[:Action]
+
+        return process_action_without_appoptics(*args) unless AppOpticsAPM.tracing?
+        begin
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:action_controller][:collect_backtraces]
+          AppOpticsAPM::API.log(nil, 'info', kvs)
+
+          process_action_without_appoptics(*args)
+        rescue Exception
+          kvs[:Status] = 500
+          kvs.delete(:Backtrace)
+          AppOpticsAPM::API.log(nil, 'info', kvs)
+          raise
+        end
+      end
+    end
+  end
+end