appoptics_apm-zearn 4.13.1

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

@@ -0,0 +1,114 @@
+# 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 ActiveRecord::Base.respond_to?(:connection_db_config)
+              # Rails 6.1++ deprecates connection_config
+              config = ActiveRecord::Base.connection_db_config.configuration_hash
+            else
+              config = ActiveRecord::Base.connection_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|^postgis/i
+                opts[:Flavor] = 'postgresql'
+              end
+            end
+          rescue StandardError => e
+            AppOpticsAPM.logger.debug "[appoptics_apm/rails] 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? && !AppOpticsAPM.tracing_layer_op?(:ar_started) && !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, :ar_started) 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, :ar_started) do
+              exec_delete_without_appoptics(sql, name, binds)
+            end
+          else
+            exec_delete_without_appoptics(sql, name, binds)
+          end
+        end
+
+        def exec_update_with_appoptics(sql, name = nil, binds = [])
+          if AppOpticsAPM.tracing? && !ignore_payload?(name)
+
+            opts = extract_trace_details(sql, name, binds)
+            AppOpticsAPM::API.trace('activerecord', opts, :ar_started) do
+              exec_update_without_appoptics(sql, name, binds)
+            end
+          else
+            exec_update_without_appoptics(sql, name, binds)
+          end
+        end
+      end # Utils
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# Copyright (c) 2019 SolarWinds, LLC.
+# All rights reserved.
+
+if AppOpticsAPM.loaded && defined?(ActiveSupport::Logger::SimpleFormatter)
+  module ActiveSupport
+    class Logger
+      class SimpleFormatter
+        # even though SimpleFormatter inherits from Logger,
+        # this will not append traceId twice,
+        # because SimpleFormatter#call does not call super
+        prepend AppOpticsAPM::Logger::Formatter
+      end
+    end
+  end
+end
+
+
+if AppOpticsAPM.loaded && defined?(ActiveSupport::TaggedLogging::Formatter)
+  module ActiveSupport
+    module TaggedLogging
+      module Formatter
+        # TODO figure out ancestors situation
+        prepend AppOpticsAPM::Logger::Formatter
+      end
+    end
+  end
+end

data/lib/appoptics_apm/frameworks/rails.rb

@@ -0,0 +1,100 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require_relative '../../../lib/appoptics_apm/inst/logger_formatter'
+
+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/active_record'
+      require 'appoptics_apm/frameworks/rails/inst/logger_formatters'
+
+      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.controller', before: 'wicked_pdf.register' do
+        AppOpticsAPM::Rails.load_instrumentation
+      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/sinatra.rb

@@ -0,0 +1,96 @@
+# 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
+      rescue => e
+        AppOpticsAPM::API.log_exception('sinatra', e)
+        raise e
+      ensure
+        report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:sinatra][:collect_backtraces]
+        AppOpticsAPM::API.log_exit('sinatra', report_kvs)
+      end
+
+      def handle_exception_with_appoptics(boom)
+        AppOpticsAPM::API.log_exception(:sinatra, 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
+
+    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
+
+          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)
+        end
+      end
+    end
+  end
+end
+
+if defined?(Sinatra) && AppOpticsAPM::Config[:sinatra][:enabled]
+  require 'appoptics_apm/inst/rack'
+
+  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(:'rabbitmq-client', e)
+          raise e
+        ensure
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:bunnyclient][:collect_backtraces]
+          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
+        kvs = {}
+        kvs[:Spec] = :pushq
+        kvs[:Flavor] = :rabbitmq
+        kvs[:RemoteHost] = @connection.host
+        kvs[:RemotePort] = @connection.port.to_i
+        kvs[:VirtualHost] = @connection.vhost
+        kvs
+      rescue => e
+        AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
+      ensure
+        return kvs
+      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(:'rabbitmq-client', e)
+          raise e
+        ensure
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:bunnyclient][:collect_backtraces]
+          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(:'rabbitmq-client', e)
+          raise e
+        ensure
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:bunnyclient][:collect_backtraces]
+          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(:'rabbitmq-client', e)
+          raise e
+        ensure
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:bunnyclient][:collect_backtraces]
+          AppOpticsAPM::API.log_exit(:'rabbitmq-client', kvs)
+        end
+      end
+    end
+  end
+end
+
+if defined?(Bunny) && AppOpticsAPM::Config[:bunnyclient][:enabled]
+  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,89 @@
+# 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)
+        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
+
+      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
+
+        AppOpticsAPM::SDK.start_trace(:'rabbitmq-consumer', nil, report_kvs) do
+          call_without_appoptics(*args)
+        end
+      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