appoptics_apm-zearn 4.13.1

data/lib/appoptics_apm/inst/curb.rb

@@ -0,0 +1,332 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+
+    # Curb instrumentation wraps instance and class methods in two classes:
+    # Curl::Easy and Curl::Multi.  This CurlUtility module is used as a common module
+    # to be shared among both modules.
+    module CurlUtility
+
+      private
+      ##
+      # appoptics_collect
+      #
+      # Used as a central area to retrieve and return values
+      # that we're interesting in reporting to AppOpticsAPM
+      #
+      def appoptics_collect(verb = nil)
+        kvs = {}
+
+        kvs[:Spec] = 'rsc'
+        kvs[:IsService] = 1
+
+        # Conditionally log query args
+        if AppOpticsAPM::Config[:curb][:log_args]
+          kvs[:RemoteURL] = url
+        else
+          kvs[:RemoteURL] = url.split('?').first
+        end
+
+        kvs[:HTTPMethod] = verb if verb
+
+        # Avoid cross host tracing for blacklisted domains
+        kvs[:blacklisted] = AppOpticsAPM::API.blacklisted?(URI(url).hostname)
+
+        kvs
+      rescue => e
+        AppOpticsAPM.logger.debug "[appoptics_apm/debug] Error capturing curb KVs: #{e.message}"
+        if AppOpticsAPM::Config[:verbose]
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+          AppOpticsAPM.logger.debug e.backtrace.join('\n')
+        end
+      ensure
+        return kvs
+      end
+      
+      ##
+      # trace_curb_method
+      #
+      # An agnostic method that will profile any Curl::Easy method (and optional args and block)
+      # that you throw at it.
+      #
+      def trace_curb_method(kvs, method, args, &block)
+        # If we're not tracing, just do a fast return.
+        unless AppOpticsAPM.tracing?
+          unless AppOpticsAPM::API.blacklisted?(URI(url).hostname)
+            self.headers['X-Trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid
+          end
+          return self.send(method, args, &block)
+        end
+
+        begin
+          response_context = nil
+          kvs.merge! appoptics_collect
+
+          AppOpticsAPM::API.log_entry(:curb, kvs)
+          kvs.clear
+
+          # The core curb call
+          unless AppOpticsAPM::API.blacklisted?(URI(url).hostname)
+            self.headers['X-Trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid
+          end
+          response = self.send(method, *args, &block)
+
+            kvs[:HTTPStatus] = response_code
+
+            # If we get a redirect, report the location header
+            if ((300..308).to_a.include? response_code) && headers.key?("Location")
+              kvs[:Location] = headers["Location"]
+            end
+
+            _, *response_headers = header_str.split(/[\r\n]+/).map(&:strip)
+            response_headers = Hash[response_headers.flat_map{ |s| s.scan(/^(\S+): (.+)/) }]
+
+            response_context = response_headers['X-Trace']
+            if response_context && !kvs[:blacklisted]
+              AppOpticsAPM::XTrace.continue_service_context(self.headers['X-Trace'], response_context)
+            end
+
+          response
+        rescue => e
+          AppOpticsAPM::API.log_exception(:curb, e)
+          raise e
+        ensure
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:curb][:collect_backtraces]
+          AppOpticsAPM::API.log_exit(:curb, kvs)
+        end
+      end
+      
+    end # CurlUtility
+
+    # Instrumentation specific to ::Curl::Easy
+    module CurlEasy
+      # Common methods
+      include AppOpticsAPM::Inst::CurlUtility
+
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :http, ::Curl::Easy)
+        AppOpticsAPM::Util.method_alias(klass, :perform, ::Curl::Easy)
+        AppOpticsAPM::Util.method_alias(klass, :http_put, ::Curl::Easy)
+        AppOpticsAPM::Util.method_alias(klass, :http_post, ::Curl::Easy)
+      end
+
+      ##
+      # http_post_with_appoptics
+      #
+      # ::Curl::Easy.new.http_post wrapper
+      #
+      def http_post_with_appoptics(*args, &block)
+        # If we're not tracing, just do a fast return.
+        if !AppOpticsAPM.tracing? || AppOpticsAPM.tracing_layer?(:curb)
+          unless AppOpticsAPM::API.blacklisted?(URI(url).hostname)
+            self.headers['X-Trace'] = AppOpticsAPM::Context.toString() if AppOpticsAPM::Context.isValid
+          end
+          return http_post_without_appoptics(*args)
+        end
+
+        kvs = {}
+        kvs[:HTTPMethod] = :POST
+
+        trace_curb_method(kvs, :http_post_without_appoptics, args, &block)
+      end
+
+      ##
+      # http_put_with_appoptics
+      #
+      # ::Curl::Easy.new.http_put wrapper
+      #
+      def http_put_with_appoptics(*args, &block)
+        # If we're not tracing, just do a fast return.
+        if !AppOpticsAPM.tracing? || AppOpticsAPM.tracing_layer?(:curb)
+          unless AppOpticsAPM::API.blacklisted?(URI(url).hostname)
+            self.headers['X-Trace'] = AppOpticsAPM::Context.toString() if AppOpticsAPM::Context.isValid
+          end
+          return http_put_without_appoptics(data)
+        end
+
+        kvs = {}
+        kvs[:HTTPMethod] = :PUT
+
+        trace_curb_method(kvs, :http_put_without_appoptics, args, &block)
+      end
+
+      ##
+      # perform_with_appoptics
+      #
+      # ::Curl::Easy.new.perform wrapper
+      #
+      def perform_with_appoptics(&block)
+        # If we're not tracing, just do a fast return.
+        # excluding curb layer: because the curb C code for easy.http calls perform,
+        # we have to make sure we don't log again
+        if !AppOpticsAPM.tracing? || AppOpticsAPM.tracing_layer?(:curb)
+          unless AppOpticsAPM::API.blacklisted?(URI(url).hostname)
+            self.headers['X-Trace'] = AppOpticsAPM::Context.toString() if AppOpticsAPM::Context.isValid
+          end
+          return perform_without_appoptics(&block)
+        end
+
+        kvs = {}
+        # This perform gets called from two places, ::Curl::Easy.new.perform
+        # and Curl::Easy.new.http_head. In the case of http_head we detect the
+        # HTTP verb via get info.
+        if self.getinfo(self.sym2curl(:nobody))
+          kvs[:HTTPMethod] = :HEAD
+        else
+          kvs[:HTTPMethod] = :GET
+        end
+
+        trace_curb_method(kvs, :perform_without_appoptics, nil, &block)
+      end
+
+      ##
+      # http_with_appoptics
+      #
+      # ::Curl::Easy.new.http wrapper
+      #
+      def http_with_appoptics(verb, &block)
+        # If we're not tracing, just do a fast return.
+        unless AppOpticsAPM.tracing?
+          unless AppOpticsAPM::API.blacklisted?(URI(url).hostname)
+            self.headers['X-Trace'] = AppOpticsAPM::Context.toString() if AppOpticsAPM::Context.isValid
+          end
+          return http_without_appoptics(verb)
+        end
+
+        kvs = {}
+        kvs[:HTTPMethod] = verb
+
+        trace_curb_method(kvs, :http_without_appoptics, [verb], &block)
+      end
+    end
+
+    ##
+    # CurlMultiCM
+    #
+    # This module contains the class method wrappers for the CurlMulti class.
+    # This module should be _extended_ by CurlMulti.
+    #
+    module CurlMultiCM
+      include AppOpticsAPM::Inst::CurlUtility
+
+      def self.extended(klass)
+        AppOpticsAPM::Util.class_method_alias(klass, :http, ::Curl::Multi)
+      end
+
+      ##
+      # http_with_appoptics
+      #
+      # ::Curl::Multi.new.http wrapper
+      #
+      def http_with_appoptics(urls_with_config, multi_options={}, &block)
+        # If we're not tracing, just do a fast return.
+        unless AppOpticsAPM.tracing?
+          urls_with_config.each do |conf|
+            unless AppOpticsAPM::API.blacklisted?(URI(conf[:url]).hostname)
+              conf[:headers] ||= {}
+              conf[:headers]['X-Trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid
+            end
+          end
+          return http_without_appoptics(urls_with_config, multi_options, &block)
+        end
+
+        begin
+          kvs = {}
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:curb][:collect_backtraces]
+
+          AppOpticsAPM::API.log_entry(:curb_multi, kvs)
+          context = AppOpticsAPM::Context.toString
+          urls_with_config.each do |conf|
+            unless AppOpticsAPM::API.blacklisted?(URI(conf[:url]).hostname)
+              conf[:headers] ||= {}
+              conf[:headers]['X-Trace'] = context if AppOpticsAPM::Context.isValid
+            end
+          end
+
+          traces = []
+          # The core curb call
+          http_without_appoptics(urls_with_config, multi_options) do |easy, response_code, method|
+            # this is the only way we can access the headers, they are not exposed otherwise
+            unless AppOpticsAPM::API.blacklisted?(URI(easy.url).hostname)
+              xtrace = easy.header_str.scan(/X-Trace: ([0-9A-F]*)/).map{ |m| m[0] }
+              traces << xtrace[0] unless xtrace.empty?
+            end
+            block.call(easy, response_code, method) if block
+          end
+          AppOpticsAPM::XTrace.continue_service_context(context, traces.pop) unless traces.empty?
+        rescue => e
+          AppOpticsAPM::API.log_exception(:curb_multi, e)
+          raise e
+        ensure
+          AppOpticsAPM::API.log_multi_exit(:curb_multi, traces)
+        end
+      end
+    end
+
+    ##
+    # CurlMultiIM
+    #
+    # This module contains the instance method wrappers for the CurlMulti class.
+    # This module should be _included_ into CurlMulti.
+    #
+    module CurlMultiIM
+      include AppOpticsAPM::Inst::CurlUtility
+
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :perform, ::Curl::Multi)
+      end
+
+      ##
+      # perform_with_appoptics
+      #
+      # ::Curl::Multi.new.perform wrapper
+      #
+      # the reason we instrument this method is because it can be called directly,
+      # therefore we exclude calls that already have a curb layer assigned
+      # Be aware: this method is also called from the c-implementation
+      #
+      def perform_with_appoptics(&block)
+        # If we're not tracing or we're already tracing curb, just do a fast return.
+        if !AppOpticsAPM.tracing? || [:curb, :curb_multi].include?(AppOpticsAPM.layer)
+          self.requests.each do |request|
+            request = request[1] if request.is_a?(Array)
+            unless AppOpticsAPM::API.blacklisted?(URI(request.url).hostname)
+              request.headers['X-Trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid
+            end
+          end
+          return perform_without_appoptics(&block)
+        end
+
+        begin
+          kvs = {}
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:curb][:collect_backtraces]
+
+          AppOpticsAPM::API.log_entry(:curb_multi, kvs)
+
+          self.requests.each do |request|
+            request = request[1] if request.is_a?(Array)
+            unless AppOpticsAPM::API.blacklisted?(URI(request.url).hostname)
+              request.headers['X-Trace'] = AppOpticsAPM::Context.toString if AppOpticsAPM::Context.isValid
+            end
+          end
+
+          perform_without_appoptics(&block)
+        rescue => e
+          AppOpticsAPM::API.log_exception(:curb_multi, e)
+          raise e
+        ensure
+          AppOpticsAPM::API.log_exit(:curb_multi)
+        end
+      end
+    end
+  end
+end
+
+if AppOpticsAPM::Config[:curb][:enabled] && defined?(::Curl)
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting curb' if AppOpticsAPM::Config[:verbose]
+  AppOpticsAPM::Util.send_include(::Curl::Easy, AppOpticsAPM::Inst::CurlEasy)
+  AppOpticsAPM::Util.send_extend(::Curl::Multi, AppOpticsAPM::Inst::CurlMultiCM)
+  AppOpticsAPM::Util.send_include(::Curl::Multi, AppOpticsAPM::Inst::CurlMultiIM)
+end

data/lib/appoptics_apm/inst/dalli.rb

@@ -0,0 +1,85 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module Dalli
+      include AppOpticsAPM::API::Memcache
+
+      def self.included(cls)
+        cls.class_eval do
+          AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting memcache (dalli)' if AppOpticsAPM::Config[:verbose]
+          if ::Dalli::Client.private_method_defined? :perform
+            alias perform_without_appoptics perform
+            alias perform perform_with_appoptics
+          else
+            AppOpticsAPM.logger.warn '[appoptics_apm/loading] Couldn\'t properly instrument Memcache (Dalli).  Partial traces may occur.'
+          end
+
+          if ::Dalli::Client.method_defined? :get_multi
+            alias get_multi_without_appoptics get_multi
+            alias get_multi get_multi_with_appoptics
+          end
+        end
+      end
+
+      def perform_with_appoptics(*all_args, &blk)
+        op, key, *args = *all_args
+
+        report_kvs = {}
+        report_kvs[:KVOp] = op
+        report_kvs[:KVKey] = key
+        if @servers.is_a?(Array) && !@servers.empty?
+          report_kvs[:RemoteHost] = @servers.join(", ")
+        end
+
+        if AppOpticsAPM.tracing? && !AppOpticsAPM.tracing_layer_op?(:get_multi)
+          AppOpticsAPM::API.trace(:memcache, report_kvs) do
+            result = perform_without_appoptics(*all_args, &blk)
+
+            # Clear the hash for a potential info event
+            report_kvs.clear
+            report_kvs[:KVHit] = memcache_hit?(result) if op == :get && key.class == String
+            report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:dalli][:collect_backtraces]
+
+            result
+          end
+        else
+          perform_without_appoptics(*all_args, &blk)
+        end
+      end
+
+      def get_multi_with_appoptics(*keys)
+        return get_multi_without_appoptics(*keys) unless AppOpticsAPM.tracing?
+
+        info_kvs = {}
+
+        begin
+          info_kvs[:KVKeyCount] = keys.flatten.length
+          info_kvs[:KVKeyCount] = (info_kvs[:KVKeyCount] - 1) if keys.last.is_a?(Hash) || keys.last.nil?
+          if @servers.is_a?(Array) && !@servers.empty?
+            info_kvs[:RemoteHost] = @servers.join(", ")
+          end
+        rescue => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
+        end
+
+        info_kvs[:KVOp] = :get_multi
+        info_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:dalli][:collect_backtraces]
+        AppOpticsAPM::API.trace(:memcache, info_kvs, :get_multi) do
+          values = get_multi_without_appoptics(*keys)
+
+          info_kvs[:KVHitCount] = values.length
+
+          values
+        end
+      end
+    end
+  end
+end
+
+if defined?(Dalli) && AppOpticsAPM::Config[:dalli][:enabled]
+  ::Dalli::Client.module_eval do
+    include AppOpticsAPM::Inst::Dalli
+  end
+end

data/lib/appoptics_apm/inst/delayed_job.rb

@@ -0,0 +1,92 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+if defined?(Delayed)
+  module AppOpticsAPM
+    module Inst
+      module DelayedJob
+        ##
+        # ForkHandler
+        #
+        # Since delayed job doesn't offer a hook into `after_fork`, we alias the method
+        # here to do our magic after a fork happens.
+        #
+        module ForkHandler
+          def self.extended(klass)
+            AppOpticsAPM::Util.class_method_alias(klass, :after_fork, ::Delayed::Worker)
+          end
+
+          def after_fork_with_appoptics
+            AppOpticsAPM.logger.info '[appoptics_apm/delayed_job] Detected fork.  Restarting AppOpticsAPM reporter.' if AppOpticsAPM::Config[:verbose]
+            AppOpticsAPM::Reporter.restart unless ENV.key?('APPOPTICS_GEM_TEST')
+
+            after_fork_without_appoptics
+          end
+        end
+
+        ##
+        # AppOpticsAPM::Inst::DelayedJob::Plugin
+        #
+        # The AppOpticsAPM DelayedJob plugin.  Here we wrap `enqueue` and
+        # `perform` to capture the timing of the bits we're interested
+        # in.
+        #
+        class Plugin < Delayed::Plugin
+          callbacks do |lifecycle|
+
+            # enqueue
+            if AppOpticsAPM::Config[:delayed_jobclient][:enabled]
+              lifecycle.around(:enqueue) do |job, &block|
+                begin
+                  report_kvs = {}
+                  report_kvs[:Spec] = :pushq
+                  report_kvs[:Flavor] = :DelayedJob
+                  report_kvs[:JobName] = job.name
+                  report_kvs[:MsgID] = job.id
+                  report_kvs[:Queue] = job.queue if job.queue
+                  report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:delayed_jobclient][:collect_backtraces]
+
+                  AppOpticsAPM::API.trace(:'delayed_job-client', report_kvs) do
+                    block.call(job)
+                  end
+                end
+              end
+            end
+
+            # invoke_job
+            if AppOpticsAPM::Config[:delayed_jobworker][:enabled]
+              lifecycle.around(:perform) do |worker, job, &block|
+                begin
+                  report_kvs = {}
+                  report_kvs[:Spec] = :job
+                  report_kvs[:Flavor] = :DelayedJob
+                  report_kvs[:JobName] = job.name
+                  report_kvs[:MsgID] = job.id
+                  report_kvs[:Queue] = job.queue if job.queue
+                  report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:delayed_jobworker][:collect_backtraces]
+
+                  # DelayedJob Specific KVs
+                  report_kvs[:priority] = job.priority
+                  report_kvs[:attempts] = job.attempts
+                  report_kvs[:WorkerName] = job.locked_by
+                rescue => e
+                  AppOpticsAPM.logger.warn "[appoptics_apm/warning] inst/delayed_job.rb: #{e.message}"
+                end
+
+                AppOpticsAPM::SDK.start_trace(:'delayed_job-worker', nil, report_kvs) do
+                  result = block.call(worker, job)
+                  AppOpticsAPM::API.log_exception(:'delayed_job-worker', job.error) if job.error
+                  result
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting delayed_job' if AppOpticsAPM::Config[:verbose]
+  AppOpticsAPM::Util.send_extend(::Delayed::Worker, AppOpticsAPM::Inst::DelayedJob::ForkHandler)
+  Delayed::Worker.plugins << AppOpticsAPM::Inst::DelayedJob::Plugin
+end

data/lib/appoptics_apm/inst/em-http-request.rb

@@ -0,0 +1,101 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module EventMachine
+      module HttpConnection
+        def setup_request_with_appoptics(*args, &block)
+          context = AppOpticsAPM::Context.toString
+          blacklisted = AppOpticsAPM::API.blacklisted?(@uri)
+
+          if AppOpticsAPM.tracing?
+            report_kvs = {}
+
+            begin
+              report_kvs[:Spec] = 'rsc'
+              report_kvs[:IsService] = 1
+              report_kvs[:RemoteURL] = @uri
+              report_kvs[:HTTPMethod] = args[0]
+              report_kvs[:Blacklisted] = true if blacklisted
+              report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:em_http_request][:collect_backtraces]
+            rescue => e
+              AppOpticsAPM.logger.debug "[appoptics_apm/debug] em-http-request KV error: #{e.inspect}"
+            end
+
+            context = AppOpticsAPM::API.log_entry('em-http-request', report_kvs)
+          end
+          client = setup_request_without_appoptics(*args, &block)
+          client.req.headers['X-Trace'] = context unless blacklisted
+          client
+        end
+      end
+
+      module HttpClient
+        def parse_response_header_with_appoptics(*args, &block)
+          report_kvs = {}
+          xtrace = nil
+          blacklisted = AppOpticsAPM::API.blacklisted?(@uri)
+
+          begin
+            report_kvs[:HTTPStatus] = args[2]
+            report_kvs[:Async] = 1
+          rescue => e
+            AppOpticsAPM.logger.debug "[appoptics_apm/debug] em-http-request KV error: #{e.inspect}"
+          end
+
+          parse_response_header_without_appoptics(*args, &block)
+
+          unless blacklisted
+            headers = args[0]
+            context = AppOpticsAPM::Context.toString
+            task_id = AppOpticsAPM::XTrace.task_id(context)
+
+            if headers.is_a?(Hash) && headers.key?('X-Trace')
+              xtrace = headers['X-Trace']
+            end
+
+            if AppOpticsAPM::XTrace.valid?(xtrace) && AppOpticsAPM.tracing?
+
+              # Assure that we received back a valid X-Trace with the same task_id
+              if task_id == AppOpticsAPM::XTrace.task_id(xtrace)
+                AppOpticsAPM::Context.fromString(xtrace)
+              else
+                AppOpticsAPM.logger.debug "[appoptics_apm/em-http] Mismatched returned X-Trace ID : #{xtrace}"
+              end
+            end
+
+          end
+        ensure
+          AppOpticsAPM::API.log_exit(:'em-http-request', report_kvs)
+        end
+      end
+    end
+  end
+end
+
+if defined?(EventMachine::HttpConnection) && defined?(EventMachine::HttpClient) && AppOpticsAPM::Config[:em_http_request][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting em-http-request' if AppOpticsAPM::Config[:verbose]
+
+  class EventMachine::HttpConnection
+    include AppOpticsAPM::Inst::EventMachine::HttpConnection
+
+    if method_defined?(:setup_request)
+      class_eval 'alias :setup_request_without_appoptics :setup_request'
+      class_eval 'alias :setup_request :setup_request_with_appoptics'
+    else
+      AppOpticsAPM.logger.warn '[appoptics_apm/loading] Couldn\'t properly instrument em-http-request (:setup_request).  Partial traces may occur.'
+    end
+  end
+
+  class EventMachine::HttpClient
+    include AppOpticsAPM::Inst::EventMachine::HttpClient
+
+    if method_defined?(:parse_response_header)
+      class_eval 'alias :parse_response_header_without_appoptics :parse_response_header'
+      class_eval 'alias :parse_response_header :parse_response_header_with_appoptics'
+    else
+      AppOpticsAPM.logger.warn '[appoptics_apm/loading] Couldn\'t properly instrument em-http-request (:parse_response_header).  Partial traces may occur.'
+    end
+  end
+end