appoptics_apm_mnfst 4.5.2

data/lib/appoptics_apm/inst/resque.rb

@@ -0,0 +1,151 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'socket'
+require 'json'
+
+module AppOpticsAPM
+  module Inst
+    module ResqueClient
+      def self.included(klass)
+        klass.send :extend, ::Resque
+        AppOpticsAPM::Util.method_alias(klass, :enqueue, ::Resque)
+        AppOpticsAPM::Util.method_alias(klass, :enqueue_to, ::Resque)
+        AppOpticsAPM::Util.method_alias(klass, :dequeue, ::Resque)
+      end
+
+      def extract_trace_details(op, klass, args)
+        report_kvs = {}
+
+        begin
+          report_kvs[:Spec] = :pushq
+          report_kvs[:Flavor] = :resque
+          report_kvs[:JobName] = klass.to_s
+
+          if AppOpticsAPM::Config[:resqueclient][:log_args]
+            kv_args = args.to_json
+
+            # Limit the argument json string to 1024 bytes
+            if kv_args.length > 1024
+              report_kvs[:Args] = kv_args[0..1023] + '...[snipped]'
+            else
+              report_kvs[:Args] = kv_args
+            end
+          end
+          report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:resqueclient][:collect_backtraces]
+          report_kvs[:Queue] = klass.instance_variable_get(:@queue)
+        rescue => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
+        end
+
+        report_kvs
+      end
+
+      def enqueue_with_appoptics(klass, *args)
+        if AppOpticsAPM.tracing?
+          report_kvs = extract_trace_details(:enqueue, klass, args)
+
+          AppOpticsAPM::API.trace(:'resque-client', report_kvs, :enqueue) do
+            enqueue_without_appoptics(klass, *args)
+          end
+        else
+          enqueue_without_appoptics(klass, *args)
+        end
+      end
+
+      def enqueue_to_with_appoptics(queue, klass, *args)
+        if AppOpticsAPM.tracing? && !AppOpticsAPM.tracing_layer_op?(:enqueue)
+          report_kvs = extract_trace_details(:enqueue_to, klass, args)
+          report_kvs[:Queue] = queue.to_s if queue
+
+          AppOpticsAPM::API.trace(:'resque-client', report_kvs) do
+            enqueue_to_without_appoptics(queue, klass, *args)
+          end
+        else
+          enqueue_to_without_appoptics(queue, klass, *args)
+        end
+      end
+
+      def dequeue_with_appoptics(klass, *args)
+        if AppOpticsAPM.tracing?
+          report_kvs = extract_trace_details(:dequeue, klass, args)
+
+          AppOpticsAPM::API.trace(:'resque-client', report_kvs) do
+            dequeue_without_appoptics(klass, *args)
+          end
+        else
+          dequeue_without_appoptics(klass, *args)
+        end
+      end
+    end
+
+    module ResqueWorker
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :perform, ::Resque::Worker)
+      end
+
+      def perform_with_appoptics(job)
+        report_kvs = {}
+
+        begin
+          report_kvs[:Spec] = :job
+          report_kvs[:Flavor] = :resque
+          report_kvs[:JobName] = job.payload['class'].to_s
+          report_kvs[:Queue] = job.queue
+
+          # Set these keys for the ability to separate out
+          # background tasks into a separate app on the server-side UI
+
+          report_kvs[:'HTTP-Host'] = Socket.gethostname
+          report_kvs[:Controller] = "Resque_#{job.queue}"
+          report_kvs[:Action] = job.payload['class'].to_s
+          report_kvs[:URL] = "/resque/#{job.queue}/#{job.payload['class']}"
+
+          if AppOpticsAPM::Config[:resqueworker][:log_args]
+            kv_args = job.payload['args'].to_json
+
+            # Limit the argument json string to 1024 bytes
+            if kv_args.length > 1024
+              report_kvs[:Args] = kv_args[0..1023] + '...[snipped]'
+            else
+              report_kvs[:Args] = kv_args
+            end
+          end
+
+          report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:resqueworker][:collect_backtraces]
+        rescue => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
+        end
+
+        AppOpticsAPM::SDK.start_trace(:'resque-worker', nil, report_kvs) do
+          perform_without_appoptics(job)
+        end
+      end
+    end
+
+    module ResqueJob
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :fail, ::Resque::Job)
+      end
+
+      def fail_with_appoptics(exception)
+        if AppOpticsAPM.tracing?
+          AppOpticsAPM::API.log_exception(:resque, exception)
+        end
+        fail_without_appoptics(exception)
+      end
+    end
+  end
+end
+
+if defined?(Resque)
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting resque' if AppOpticsAPM::Config[:verbose]
+
+  AppOpticsAPM::Util.send_include(Resque,         AppOpticsAPM::Inst::ResqueClient) if AppOpticsAPM::Config[:resqueclient][:enabled]
+  AppOpticsAPM::Util.send_include(Resque::Worker, AppOpticsAPM::Inst::ResqueWorker) if AppOpticsAPM::Config[:resqueworker][:enabled]
+  if AppOpticsAPM::Config[:resqueclient][:enabled] || AppOpticsAPM::Config[:resqueworker][:enabled]
+    AppOpticsAPM::Util.send_include(Resque::Job,    AppOpticsAPM::Inst::ResqueJob)
+  end
+end
+
+

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

@@ -0,0 +1,48 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module RestClientRequest
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :execute, ::RestClient::Request)
+      end
+
+      ##
+      # execute_with_appoptics
+      #
+      # The wrapper method for RestClient::Request.execute
+      #
+      def execute_with_appoptics(&block)
+        blacklisted = AppOpticsAPM::API.blacklisted?(url)
+
+        unless AppOpticsAPM.tracing?
+          xtrace = AppOpticsAPM::Context.toString
+          @processed_headers['X-Trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::XTrace.valid?(xtrace) && !blacklisted
+          return execute_without_appoptics(&block)
+        end
+
+        begin
+          kvs = {}
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:rest_client][:collect_backtraces]
+          AppOpticsAPM::API.log_entry('rest-client', kvs)
+
+          @processed_headers['X-Trace'] = AppOpticsAPM::Context.toString unless blacklisted
+
+          # The core rest-client call
+          execute_without_appoptics(&block)
+        rescue => e
+          AppOpticsAPM::API.log_exception('rest-client', e)
+          raise e
+        ensure
+          AppOpticsAPM::API.log_exit('rest-client')
+        end
+      end
+    end
+  end
+end
+
+if defined?(RestClient) && AppOpticsAPM::Config[:rest_client][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting rest-client' if AppOpticsAPM::Config[:verbose]
+  AppOpticsAPM::Util.send_include(RestClient::Request, AppOpticsAPM::Inst::RestClientRequest)
+end

data/lib/appoptics_apm/inst/sequel.rb

@@ -0,0 +1,178 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    ##
+    # AppOpticsAPM::Inst::Sequel
+    #
+    # The common (shared) methods used by the AppOpticsAPM Sequel instrumentation
+    # across multiple modules/classes.
+    #
+    module Sequel
+      ##
+      # extract_trace_details
+      #
+      # Given SQL and the options hash, this method extracts the interesting
+      # bits for reporting to the AppOptics dashboard.
+      #
+      def extract_trace_details(sql, opts)
+        kvs = {}
+
+        if !sql.is_a?(String)
+          kvs[:IsPreparedStatement] = true
+        end
+
+        if ::Sequel::VERSION > '4.36.0' && !sql.is_a?(String)
+          # In 4.37.0, sql was converted to a prepared statement object
+          sql = sql.prepared_sql unless sql.is_a?(Symbol)
+        end
+
+        if AppOpticsAPM::Config[:sanitize_sql]
+          # Sanitize SQL and don't report binds
+          if sql.is_a?(Symbol)
+            kvs[:Query] = sql
+          else
+            kvs[:Query] = AppOpticsAPM::Util.sanitize_sql(sql)
+          end
+        else
+          # Report raw SQL and any binds if they exist
+          kvs[:Query] = sql.to_s
+          kvs[:QueryArgs] = opts[:arguments] if opts.is_a?(Hash) && opts.key?(:arguments)
+        end
+
+        kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:sequel][:collect_backtraces]
+
+        if ::Sequel::VERSION < '3.41.0' && !(self.class.to_s =~ /Dataset$/)
+          db_opts = @opts
+        elsif @pool
+          db_opts = @pool.db.opts
+        else
+          db_opts = @db.opts
+        end
+
+        kvs[:Database]   = db_opts[:database]
+        kvs[:RemoteHost] = db_opts[:host]
+        kvs[:RemotePort] = db_opts[:port] if db_opts.key?(:port)
+        kvs[:Flavor]     = db_opts[:adapter]
+      rescue => e
+        AppOpticsAPM.logger.debug "[appoptics_apm/debug Error capturing Sequel KVs: #{e.message}" if AppOpticsAPM::Config[:verbose]
+      ensure
+        return kvs
+      end
+
+      ##
+      # exec_with_appoptics
+      #
+      # This method wraps and routes the call to the specified
+      # original method call
+      #
+      def exec_with_appoptics(method, sql, opts = ::Sequel::OPTS, &block)
+        if AppOpticsAPM.tracing?
+          kvs = extract_trace_details(sql, opts)
+          AppOpticsAPM::API.log_entry(:sequel, kvs)
+        end
+
+        send(method, sql, opts, &block)
+      rescue => e
+        AppOpticsAPM::API.log_exception(:sequel, e)
+        raise e
+      ensure
+        AppOpticsAPM::API.log_exit(:sequel)
+      end
+    end
+
+    module SequelDatabase
+      include AppOpticsAPM::Inst::Sequel
+
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :run, ::Sequel::Database)
+        AppOpticsAPM::Util.method_alias(klass, :execute_ddl, ::Sequel::Database)
+        AppOpticsAPM::Util.method_alias(klass, :execute_dui, ::Sequel::Database)
+        AppOpticsAPM::Util.method_alias(klass, :execute_insert, ::Sequel::Database)
+      end
+
+      def run_with_appoptics(sql, opts = ::Sequel::OPTS)
+        if AppOpticsAPM.tracing?
+          kvs = extract_trace_details(sql, opts)
+          AppOpticsAPM::API.log_entry(:sequel, kvs)
+        end
+
+        run_without_appoptics(sql, opts)
+      rescue => e
+        AppOpticsAPM::API.log_exception(:sequel, e)
+        raise e
+      ensure
+        AppOpticsAPM::API.log_exit(:sequel)
+      end
+
+      def execute_ddl_with_appoptics(sql, opts = ::Sequel::OPTS, &block)
+        # If we're already tracing a sequel operation, then this call likely came
+        # from Sequel::Dataset.  In this case, just pass it on.
+        return execute_ddl_without_appoptics(sql, opts, &block) if AppOpticsAPM.tracing_layer?(:sequel)
+
+        exec_with_appoptics(:execute_ddl_without_appoptics, sql, opts, &block)
+      end
+
+      def execute_dui_with_appoptics(sql, opts = ::Sequel::OPTS, &block)
+        # If we're already tracing a sequel operation, then this call likely came
+        # from Sequel::Dataset.  In this case, just pass it on.
+        return execute_dui_without_appoptics(sql, opts, &block) if AppOpticsAPM.tracing_layer?(:sequel)
+
+        exec_with_appoptics(:execute_dui_without_appoptics, sql, opts, &block)
+      end
+
+      def execute_insert_with_appoptics(sql, opts = ::Sequel::OPTS, &block)
+        # If we're already tracing a sequel operation, then this call likely came
+        # from Sequel::Dataset.  In this case, just pass it on.
+        return execute_insert_without_appoptics(sql, opts, &block) if AppOpticsAPM.tracing_layer?(:sequel)
+
+        exec_with_appoptics(:execute_insert_without_appoptics, sql, opts, &block)
+      end
+    end # module SequelDatabase
+
+    module SequelDataset
+      include AppOpticsAPM::Inst::Sequel
+
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :execute, ::Sequel::Dataset)
+        AppOpticsAPM::Util.method_alias(klass, :execute_ddl, ::Sequel::Dataset)
+        AppOpticsAPM::Util.method_alias(klass, :execute_dui, ::Sequel::Dataset)
+        AppOpticsAPM::Util.method_alias(klass, :execute_insert, ::Sequel::Dataset)
+      end
+
+      def execute_with_appoptics(sql, opts = ::Sequel::OPTS, &block)
+        exec_with_appoptics(:execute_without_appoptics, sql, opts, &block)
+      end
+
+      def execute_ddl_with_appoptics(sql, opts = ::Sequel::OPTS, &block)
+        exec_with_appoptics(:execute_ddl_without_appoptics, sql, opts, &block)
+      end
+
+      def execute_dui_with_appoptics(sql, opts = ::Sequel::OPTS, &block)
+        exec_with_appoptics(:execute_dui_without_appoptics, sql, opts, &block)
+      end
+
+      def execute_insert_with_appoptics(sql, opts = ::Sequel::OPTS, &block)
+        exec_with_appoptics(:execute_insert_without_appoptics, sql, opts, &block)
+      end
+
+    end # module SequelDataset
+  end # module Inst
+end # module AppOpticsAPM
+
+if AppOpticsAPM::Config[:sequel][:enabled]
+  if defined?(::Sequel) && ::Sequel::VERSION < '4.0.0'
+    # For versions before 4.0.0, Sequel::OPTS wasn't defined.
+    # Define it as an empty hash for backwards compatibility.
+    module ::Sequel
+      OPTS = {}
+    end
+  end
+
+  if defined?(::Sequel)
+    AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting sequel' if AppOpticsAPM::Config[:verbose]
+    AppOpticsAPM::Util.send_include(::Sequel::Database, AppOpticsAPM::Inst::SequelDatabase)
+    AppOpticsAPM::Util.send_include(::Sequel::Dataset, AppOpticsAPM::Inst::SequelDataset)
+  end
+end

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

@@ -0,0 +1,55 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  class SidekiqClient
+    def collect_kvs(args)
+      begin
+        # Attempt to collect up pertinent info.  If we hit something unexpected,
+        # keep calm and instrument on.
+
+        report_kvs = {}
+        worker_class, msg, queue, _ = args
+
+        report_kvs[:Spec]      = :pushq
+        report_kvs[:Flavor]    = :sidekiq
+        report_kvs[:Queue]     = queue
+        report_kvs[:Retry]     = msg['retry']
+        report_kvs[:JobName]   = msg['wrapped'] || worker_class
+        report_kvs[:MsgID]     = msg['jid']
+        report_kvs[:Args]      = msg['args'].to_s[0..1024] if AppOpticsAPM::Config[:sidekiqclient][:log_args]
+        report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:sidekiqclient][:collect_backtraces]
+      rescue => e
+        AppOpticsAPM.logger.warn "[appoptics_apm/sidekiq] Non-fatal error capturing KVs: #{e.message}"
+      end
+      report_kvs
+    end
+
+    def call(*args)
+      # args: 0: worker_class, 1: msg, 2: queue, 3: redis_pool
+      if AppOpticsAPM.tracing?
+        report_kvs = collect_kvs(args)
+        AppOpticsAPM::API.log_entry(:'sidekiq-client', report_kvs)
+        args[1]['SourceTrace'] = AppOpticsAPM::Context.toString
+      end
+
+      result = yield
+    rescue => e
+      AppOpticsAPM::API.log_exception(:'sidekiq-client', e, { :JobID => result['jid'] })
+      raise
+    ensure
+      AppOpticsAPM::API.log_exit(:'sidekiq-client', { :JobID => result['jid'] })
+    end
+  end
+end
+
+if defined?(Sidekiq) && AppOpticsAPM::Config[:sidekiqclient][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting sidekiq client' if AppOpticsAPM::Config[:verbose]
+
+  Sidekiq.configure_client do |config|
+    config.client_middleware do |chain|
+      AppOpticsAPM.logger.info '[appoptics_apm/loading] Adding Sidekiq client middleware' if AppOpticsAPM::Config[:verbose]
+      chain.add AppOpticsAPM::SidekiqClient
+    end
+  end
+end

data/lib/appoptics_apm/inst/sidekiq-worker.rb

@@ -0,0 +1,65 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  class SidekiqWorker
+    def collect_kvs(args)
+      begin
+        # Attempt to collect up pertinent info.  If we hit something unexpected,
+        # keep calm and instrument on.
+        report_kvs = {}
+        _worker, msg, queue = args
+
+        # Background Job Spec KVs
+        report_kvs[:Spec]       = :job
+        report_kvs[:Flavor]     = :sidekiq
+        report_kvs[:Queue]      = queue
+        report_kvs[:Retry]      = msg['retry']
+        report_kvs[:JobName]    = msg['wrapped'] || msg['class']
+        report_kvs[:MsgID]      = msg['jid']
+        report_kvs[:Args]       = msg['args'].to_s[0..1024] if AppOpticsAPM::Config[:sidekiqworker][:log_args]
+        report_kvs[:Backtrace]  = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:sidekiqworker][:collect_backtraces]
+
+        # Webserver Spec KVs
+        report_kvs[:'HTTP-Host'] = Socket.gethostname
+        report_kvs[:Controller] = "Sidekiq_#{queue}"
+        report_kvs[:Action] = msg['wrapped'] || msg['class']
+        report_kvs[:URL] = "/sidekiq/#{queue}/#{msg['wrapped'] || msg['class']}"
+      rescue => e
+        AppOpticsAPM.logger.warn "[appoptics_apm/sidekiq] Non-fatal error capturing KVs: #{e.message}"
+      end
+      report_kvs
+    end
+
+    def call(*args)
+      # args: 0: worker, 1: msg, 2: queue
+      report_kvs = collect_kvs(args)
+
+      # Something is happening across Celluloid threads where liboboe settings
+      # are being lost.  So we re-set the tracing mode to assure
+      # we sample as desired.  Setting the tracing mode will re-update
+      # the liboboe settings.
+      AppOpticsAPM.set_tracing_mode(AppOpticsAPM::Config[:tracing_mode].to_sym)
+
+      # Continue the trace from the enqueue side?
+      if args[1].is_a?(Hash) && AppOpticsAPM::XTrace.valid?(args[1]['SourceTrace'])
+        report_kvs[:SourceTrace] = args[1]['SourceTrace']
+      end
+
+      AppOpticsAPM::SDK.start_trace(:'sidekiq-worker', nil, report_kvs) do
+        yield
+      end
+    end
+  end
+end
+
+if defined?(Sidekiq) && AppOpticsAPM::Config[:sidekiqworker][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting sidekiq worker' if AppOpticsAPM::Config[:verbose]
+
+  Sidekiq.configure_server do |config|
+    config.server_middleware do |chain|
+      AppOpticsAPM.logger.info '[appoptics_apm/loading] Adding Sidekiq worker middleware' if AppOpticsAPM::Config[:verbose]
+      chain.add AppOpticsAPM::SidekiqWorker
+    end
+  end
+end