appoptics_apm 4.0.2

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

@@ -0,0 +1,101 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module ConnectionAdapters
+      module Utils
+
+        def extract_trace_details(sql, name = nil, binds = [])
+          opts = {}
+
+          begin
+            if AppOpticsAPM::Config[:sanitize_sql]
+              # Sanitize SQL and don't report binds
+              opts[:Query] = AppOpticsAPM::Util.sanitize_sql(sql)
+            else
+              # Report raw SQL and any binds if they exist
+              opts[:Query] = sql.to_s
+              if binds && !binds.empty?
+                opts[:QueryArgs] = binds.map(&:value)
+              end
+            end
+
+            opts[:Name] = name.to_s if name
+            if AppOpticsAPM::Config[:active_record] && AppOpticsAPM::Config[:active_record][:collect_backtraces]
+              opts[:Backtrace] = AppOpticsAPM::API.backtrace
+            end
+
+            if ::Rails::VERSION::MAJOR == 2
+              config = ::Rails.configuration.database_configuration[::Rails.env]
+            else
+              config = ActiveRecord::Base.connection.instance_variable_get(:@config)
+            end
+
+            if config
+              opts[:Database]   = config['database'] if config.key?('database')
+              opts[:RemoteHost] = config['host']     if config.key?('host')
+              adapter_name = config[:adapter]
+
+              case adapter_name
+              when /mysql/i
+                opts[:Flavor] = 'mysql'
+              when /postgres/i
+                opts[:Flavor] = 'postgresql'
+              end
+            end
+          rescue StandardError => e
+            AppOpticsAPM.logger.debug "Exception raised capturing ActiveRecord KVs: #{e.inspect}"
+            AppOpticsAPM.logger.debug e.backtrace.join('\n')
+          end
+
+          opts || {}
+        end
+
+        # We don't want to trace framework caches.  Only instrument SQL that
+        # directly hits the database.
+        def ignore_payload?(name)
+          %w(SCHEMA EXPLAIN CACHE).include?(name.to_s) ||
+            (name && name.to_sym == :skip_logging) ||
+            name == 'ActiveRecord::SchemaMigration Load'
+        end
+
+        def exec_query_with_appoptics(sql, name = nil, binds = [], prepare: false)
+          if AppOpticsAPM.tracing? && !ignore_payload?(name)
+
+            opts = extract_trace_details(sql, name, binds)
+            AppOpticsAPM::API.trace('activerecord', opts || {}) do
+              exec_query_without_appoptics(sql, name, binds)
+            end
+          else
+            exec_query_without_appoptics(sql, name, binds)
+          end
+        end
+
+        def exec_insert_with_appoptics(sql, name = nil, binds = [], *args)
+          if AppOpticsAPM.tracing? && !ignore_payload?(name)
+
+            opts = extract_trace_details(sql, name, binds)
+            AppOpticsAPM::API.trace('activerecord', opts || {}) do
+              exec_insert_without_appoptics(sql, name, binds, *args)
+            end
+          else
+            exec_insert_without_appoptics(sql, name, binds, *args)
+          end
+        end
+
+        def exec_delete_with_appoptics(sql, name = nil, binds = [])
+          if AppOpticsAPM.tracing? && !ignore_payload?(name)
+
+            opts = extract_trace_details(sql, name, binds)
+            AppOpticsAPM::API.trace('activerecord', opts || {}) do
+              exec_delete_without_appoptics(sql, name, binds)
+            end
+          else
+            exec_delete_without_appoptics(sql, name, binds)
+          end
+        end
+      end # Utils
+    end
+  end
+end

data/lib/appoptics_apm/frameworks/rails.rb

@@ -0,0 +1,116 @@
+# 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
+
+      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
+
+      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_2x'
+      require 'appoptics_apm/frameworks/rails/inst/action_view_30'
+      require 'appoptics_apm/frameworks/rails/inst/active_record'
+
+      AppOpticsAPM.logger.info "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
+      if ::Rails::VERSION::MAJOR > 2
+        ActiveSupport.on_load(:action_view) do
+          include AppOpticsAPM::Rails::Helpers
+        end
+      else
+        ActionView::Base.send :include, AppOpticsAPM::Rails::Helpers
+      end
+    end
+  end # Rails
+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
+      end
+    end
+  else
+    AppOpticsAPM.logger = ::Rails.logger if ::Rails.logger
+
+    AppOpticsAPM::Rails.load_initializer
+
+    Rails.configuration.after_initialize do
+      AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting rack' if AppOpticsAPM::Config[:verbose]
+      Rails.configuration.middleware.insert 0, 'AppOpticsAPM::Rack'
+
+      AppOpticsAPM::Inst.load_instrumentation
+      AppOpticsAPM::Rails.load_instrumentation
+      AppOpticsAPM::Rails.include_helpers
+
+      # Report __Init after fork when in Heroku
+      AppOpticsAPM::API.report_init unless AppOpticsAPM.heroku?
+    end
+  end
+end

data/lib/appoptics_apm/frameworks/sinatra/templates.rb

@@ -0,0 +1,56 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Sinatra
+    module Templates
+      def self.included(klass)
+        ::AppOpticsAPM::Util.method_alias(klass, :render, ::Sinatra::Templates)
+      end
+
+      def render_with_appoptics(engine, data, options = {}, locals = {}, &block)
+        if AppOpticsAPM.tracing?
+          report_kvs = {}
+
+          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
+              ::AppOpticsAPM::API.log_exit(:render, report_kvs)
+            end
+          end
+        else
+          render_without_appoptics(engine, data, options, locals, &block)
+        end
+      end
+    end
+  end
+end

data/lib/appoptics_apm/frameworks/sinatra.rb

@@ -0,0 +1,71 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Sinatra
+    module Base
+      def self.included(klass)
+        ::AppOpticsAPM::Util.method_alias(klass, :dispatch!,         ::Sinatra::Base)
+        ::AppOpticsAPM::Util.method_alias(klass, :handle_exception!, ::Sinatra::Base)
+      end
+
+      def dispatch_with_appoptics
+
+        ::AppOpticsAPM::API.log_entry('sinatra', {})
+
+        response = dispatch_without_appoptics
+
+        # Report Controller/Action and transaction as best possible
+        report_kvs = {}
+        report_kvs[:Controller] = self.class
+        report_kvs[:Action] = env['sinatra.route']
+        env['appoptics_apm.controller'] = report_kvs[:Controller]
+        env['appoptics_apm.action']     = report_kvs[:Action]
+
+        response
+      ensure
+        ::AppOpticsAPM::API.log_exit('sinatra', report_kvs)
+      end
+
+      def handle_exception_with_appoptics(boom)
+        AppOpticsAPM::API.log_exception(nil, boom)
+        handle_exception_without_appoptics(boom)
+      end
+
+      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
+
+      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
+  end
+end
+
+if defined?(::Sinatra)
+  require 'appoptics_apm/inst/rack'
+  require 'appoptics_apm/frameworks/sinatra/templates'
+
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting Sinatra' if AppOpticsAPM::Config[:verbose]
+
+  AppOpticsAPM::Inst.load_instrumentation
+
+  ::Sinatra::Base.use AppOpticsAPM::Rack
+
+  # When in the gem TEST environment, we load this instrumentation regardless.
+  # Otherwise, only when Padrino isn't around.
+  unless defined?(::Padrino) && !ENV.key?('APPOPTICS_GEM_TEST')
+    # Padrino has 'enhanced' routes and rendering so the Sinatra
+    # instrumentation won't work anyways.  Only load for pure Sinatra apps.
+    ::AppOpticsAPM::Util.send_include(::Sinatra::Base,      ::AppOpticsAPM::Sinatra::Base)
+    ::AppOpticsAPM::Util.send_include(::Sinatra::Templates, ::AppOpticsAPM::Sinatra::Templates)
+
+    # Report __Init after fork when in Heroku
+    AppOpticsAPM::API.report_init unless AppOpticsAPM.heroku?
+  end
+end

data/lib/appoptics_apm/inst/bunny-client.rb

@@ -0,0 +1,148 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module BunnyExchange
+      def self.included(klass)
+        ::AppOpticsAPM::Util.method_alias(klass, :delete, ::Bunny::Exchange)
+      end
+
+      def delete_with_appoptics(opts = {})
+        # If we're not tracing, just do a fast return.
+        return delete_without_appoptics(opts) if !AppOpticsAPM.tracing?
+
+        begin
+          kvs = {}
+          kvs[:Spec] = :pushq
+          kvs[:Flavor] = :rabbitmq
+          kvs[:Op] = :delete
+          kvs[:ExchangeType]   = @type
+          kvs[:RemoteHost]     = channel.connection.host
+          kvs[:RemotePort]     = channel.connection.port.to_i
+          kvs[:VirtualHost] = channel.connection.vhost
+
+          if @name.is_a?(String) && !@name.empty?
+            kvs[:ExchangeName] = @name
+          else
+            kvs[:ExchangeName] = :default
+          end
+
+          AppOpticsAPM::API.log_entry(:'rabbitmq-client')
+
+          delete_without_appoptics(opts)
+        rescue => e
+          AppOpticsAPM::API.log_exception(nil, e)
+          raise e
+        ensure
+          AppOpticsAPM::API.log_exit(:'rabbitmq-client', kvs)
+        end
+      end
+    end
+
+    module BunnyChannel
+      def self.included(klass)
+        ::AppOpticsAPM::Util.method_alias(klass, :basic_publish,     ::Bunny::Channel)
+        ::AppOpticsAPM::Util.method_alias(klass, :queue,             ::Bunny::Channel)
+        ::AppOpticsAPM::Util.method_alias(klass, :wait_for_confirms, ::Bunny::Channel)
+      end
+
+      def collect_channel_kvs
+        begin
+          kvs = {}
+          kvs[:Spec] = :pushq
+          kvs[:Flavor] = :rabbitmq
+          kvs[:RemoteHost] = @connection.host
+          kvs[:RemotePort] = @connection.port.to_i
+          kvs[:VirtualHost] = @connection.vhost
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:bunnyclient][:collect_backtraces]
+          kvs
+        rescue => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
+        ensure
+          return kvs
+        end
+      end
+
+      def basic_publish_with_appoptics(payload, exchange, routing_key, opts = {})
+        # If we're not tracing, just do a fast return.
+        return basic_publish_without_appoptics(payload, exchange, routing_key, opts) if !AppOpticsAPM.tracing?
+
+        begin
+          kvs = collect_channel_kvs
+
+          if exchange.respond_to?(:name)
+            kvs[:ExchangeName] = exchange.name
+          elsif exchange.respond_to?(:empty?) && !exchange.empty?
+            kvs[:ExchangeName] = exchange
+          else
+            kvs[:ExchangeName] = :default
+          end
+
+          kvs[:Queue]       = opts[:queue] if opts.key?(:queue)
+          kvs[:RoutingKey]  = routing_key if routing_key
+          kvs[:Op]          = :publish
+
+          AppOpticsAPM::API.log_entry(:'rabbitmq-client')
+
+          # Pass the tracing context as a header
+          opts[:headers] ||= {}
+          opts[:headers][:SourceTrace] = AppOpticsAPM::Context.toString if AppOpticsAPM.tracing?
+
+          basic_publish_without_appoptics(payload, exchange, routing_key, opts)
+        rescue => e
+          AppOpticsAPM::API.log_exception(nil, e)
+          raise e
+        ensure
+          AppOpticsAPM::API.log_exit(:'rabbitmq-client', kvs)
+        end
+      end
+
+      def queue_with_appoptics(name = AMQ::Protocol::EMPTY_STRING, opts = {})
+        # If we're not tracing, just do a fast return.
+        return queue_without_appoptics(name, opts) if !AppOpticsAPM.tracing?
+
+        begin
+          kvs = collect_channel_kvs
+          kvs[:Op] = :queue
+
+          AppOpticsAPM::API.log_entry(:'rabbitmq-client')
+
+          result = queue_without_appoptics(name, opts)
+          kvs[:Queue] = result.name
+          result
+        rescue => e
+          AppOpticsAPM::API.log_exception(nil, e)
+          raise e
+        ensure
+          AppOpticsAPM::API.log_exit(:'rabbitmq-client', kvs)
+        end
+      end
+
+      def wait_for_confirms_with_appoptics
+        # If we're not tracing, just do a fast return.
+        return wait_for_confirms_without_appoptics if !AppOpticsAPM.tracing?
+
+        begin
+          kvs = collect_channel_kvs
+          kvs[:Op] = :wait_for_confirms
+
+          AppOpticsAPM::API.log_entry(:'rabbitmq-client')
+
+          wait_for_confirms_without_appoptics
+        rescue => e
+          AppOpticsAPM::API.log_exception(nil, e)
+          raise e
+        ensure
+          AppOpticsAPM::API.log_exit(:'rabbitmq-client', kvs)
+        end
+      end
+    end
+  end
+end
+
+if AppOpticsAPM::Config[:bunnyclient][:enabled] && defined?(::Bunny)
+  ::AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting bunny client' if AppOpticsAPM::Config[:verbose]
+  ::AppOpticsAPM::Util.send_include(::Bunny::Exchange, ::AppOpticsAPM::Inst::BunnyExchange)
+  ::AppOpticsAPM::Util.send_include(::Bunny::Channel, ::AppOpticsAPM::Inst::BunnyChannel)
+end

data/lib/appoptics_apm/inst/bunny-consumer.rb

@@ -0,0 +1,92 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module BunnyConsumer
+      def self.included(klass)
+        ::AppOpticsAPM::Util.method_alias(klass, :call, ::Bunny::Consumer)
+      end
+
+      def collect_consumer_kvs(args)
+        begin
+          kvs = {}
+          kvs[:Spec] = :job
+          kvs[:Flavor] = :rabbitmq
+          kvs[:RemoteHost]  = @channel.connection.host
+          kvs[:RemotePort]  = @channel.connection.port.to_i
+          kvs[:VirtualHost] = @channel.connection.vhost
+
+          mp = args[1]
+          kvs[:RoutingKey] = args[0].routing_key if args[0].routing_key
+          kvs[:MsgID]      = args[1].message_id  if mp.message_id
+          kvs[:AppID]      = args[1].app_id      if mp.app_id
+          kvs[:Priority]   = args[1].priority    if mp.priority
+
+          if @queue.respond_to?(:name)
+            kvs[:Queue] = @queue.name
+          else
+            kvs[:Queue] = @queue
+          end
+
+          # Report configurable Controller/Action KVs
+          # See AppOpticsAPM::Config[:bunnyconsumer] in lib/appoptics_apm/config.rb
+          # Used for dashboard trace filtering
+          controller_key = AppOpticsAPM::Config[:bunnyconsumer][:controller]
+          if mp.respond_to?(controller_key)
+            value = mp.method(controller_key).call
+            kvs[:Controller] = value if value
+          end
+
+          action_key = AppOpticsAPM::Config[:bunnyconsumer][:action]
+          if mp.respond_to?(action_key)
+            value = mp.method(action_key).call
+            kvs[:Action] = value if value
+          end
+
+          if kvs[:Queue]
+            kvs[:URL] = "/bunny/#{kvs[:Queue]}"
+          else
+            kvs[:URL] = "/bunny/consumer"
+          end
+
+          if AppOpticsAPM::Config[:bunnyconsumer][:log_args] && @arguments
+            kvs[:Args] = @arguments.to_s
+          end
+
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:bunnyconsumer][:collect_backtraces]
+
+          kvs
+        rescue => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
+        ensure
+          return kvs
+        end
+      end
+
+      def call_with_appoptics(*args)
+        report_kvs = collect_consumer_kvs(args)
+
+        # If SourceTrace was passed, capture and report it
+        headers = args[1][:headers]
+
+        if headers && headers['SourceTrace']
+          report_kvs[:SourceTrace] = headers['SourceTrace']
+
+          # Remove SourceTrace
+          headers.delete('SourceTrace')
+        end
+
+        result = AppOpticsAPM::API.start_trace(:'rabbitmq-consumer', nil, report_kvs) do
+          call_without_appoptics(*args)
+        end
+        result[0]
+      end
+    end
+  end
+end
+
+if AppOpticsAPM::Config[:bunnyconsumer][:enabled] && defined?(::Bunny)
+  ::AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting bunny consumer' if AppOpticsAPM::Config[:verbose]
+  ::AppOpticsAPM::Util.send_include(::Bunny::Consumer, ::AppOpticsAPM::Inst::BunnyConsumer)
+end