oneapm_rpm 1.1.0

data/lib/one_apm/inst/framework/sinatra/ignorer.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module OneApm
+  module Agent
+    module Instrumentation
+      module Sinatra
+        module Ignorer
+
+          def self.should_ignore?(app, type)
+            return false if !app.settings.respond_to?(:oneapm_ignores)
+
+            app.settings.oneapm_ignores[type].any? do |pattern|
+              pattern.match(app.request.path_info)
+            end
+          end
+
+          def oneapm_ignore(*routes)
+            set_oneapm_ignore(:routes, *routes)
+          end
+
+          def oneapm_ignore_apdex(*routes)
+            set_oneapm_ignore(:apdex, *routes)
+          end
+
+          def oneapm_ignore_enduser(*routes)
+            set_oneapm_ignore(:enduser, *routes)
+          end
+
+          private
+
+          def set_oneapm_ignore(type, *routes)
+            # Important to default this in the context of the actual app
+            # If it's done at register time, ignores end up shared between apps.
+            set :oneapm_ignores, Hash.new([]) if !respond_to?(:oneapm_ignores)
+
+            # If we call an ignore without a route, it applies to the whole app
+            routes = ["*"] if routes.empty?
+
+            settings.oneapm_ignores[type] += routes.map do |r|
+              # Ugly sending to private Base#compile, but we want to mimic
+              # exactly Sinatra's mapping of route text to regex
+              send(:compile, r).first
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/inst/framework/sinatra/transaction_namer.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+module OneApm
+  module Agent
+    module Instrumentation
+      module Sinatra
+        module TransactionNamer
+          extend self
+
+          def transaction_name_for_route(env, request)
+            name = route_for_sinatra(env)
+            name = route_name_for_padrino(request) if name.nil?
+
+            transaction_name(name, request) unless name.nil?
+          end
+
+          def initial_transaction_name(request)
+            transaction_name(OneApm::Transaction::UNKNOWN_METRIC, request)
+          end
+
+          def transaction_name(route_text, request)
+            verb = http_verb(request)
+
+            route_text = route_text.source if route_text.is_a?(Regexp)
+            name = route_text.gsub(%r{^[/^\\A]*(.*?)[/\$\?\\z]*$}, '\1')
+            name = "#{verb} #{name}" unless verb.nil?
+            name
+          rescue => e
+            ::OneApm::Agent.logger.debug("#{e.class} : #{e.message} - Error encountered trying to identify Sinatra transaction name")
+            OneApm::Transaction::UNKNOWN_METRIC
+          end
+
+          def http_verb(request)
+            request.request_method if request.respond_to?(:request_method)
+          end
+
+          # For bare Sinatra, our override on process_route captures the last
+          # route into the environment for us to use later on
+          def route_for_sinatra(env)
+            env["oneapm.last_route"]
+          end
+
+          # For Padrino, the request object has a copy of the matched route
+          # on it when we go to evaluating, so we can just retrieve that
+          def route_name_for_padrino(request)
+            request.route_obj.original_path
+          rescue
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/inst/http_clients/curb.rb

@@ -0,0 +1,189 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  named :curb
+
+  CURB_MINIMUM_VERSION = ::OneApm::VersionNumber.new("0.8.1")
+
+  depends_on do
+    defined?(::Curl) && defined?(::Curl::CURB_VERSION) &&
+      ::OneApm::VersionNumber.new(::Curl::CURB_VERSION) >= CURB_MINIMUM_VERSION
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Curb instrumentation'
+    require 'one_apm/agent/cross_app/cross_app_tracing'
+    require 'one_apm/support/http_clients/curb_wrappers'
+  end
+
+  executes do
+    class Curl::Easy
+
+      attr_accessor :_oa_instrumented,
+                    :_oa_http_verb,
+                    :_oa_header_str,
+                    :_oa_original_on_header,
+                    :_oa_original_on_complete,
+                    :_oa_serial
+
+      # We have to hook these three methods separately, as they don't use
+      # Curl::Easy#http
+      def http_head_with_oneapm(*args, &blk)
+        self._oa_http_verb = :HEAD
+        http_head_without_oneapm(*args, &blk)
+      end
+      alias_method :http_head_without_oneapm, :http_head
+      alias_method :http_head, :http_head_with_oneapm
+
+      def http_post_with_oneapm(*args, &blk)
+        self._oa_http_verb = :POST
+        http_post_without_oneapm(*args, &blk)
+      end
+      alias_method :http_post_without_oneapm, :http_post
+      alias_method :http_post, :http_post_with_oneapm
+
+      def http_put_with_oneapm(*args, &blk)
+        self._oa_http_verb = :PUT
+        http_put_without_oneapm(*args, &blk)
+      end
+      alias_method :http_put_without_oneapm, :http_put
+      alias_method :http_put, :http_put_with_oneapm
+
+
+      # Hook the #http method to set the verb.
+      def http_with_oneapm( verb )
+        self._oa_http_verb = verb.to_s.upcase
+        http_without_oneapm( verb )
+      end
+
+      alias_method :http_without_oneapm, :http
+      alias_method :http, :http_with_oneapm
+
+
+      # Hook the #perform method to mark the request as non-parallel.
+      def perform_with_oneapm
+        self._oa_serial = true
+        perform_without_oneapm
+      end
+
+      alias_method :perform_without_oneapm, :perform
+      alias_method :perform, :perform_with_oneapm
+
+      # We override this method in order to ensure access to header_str even
+      # though we use an on_header callback
+      def header_str_with_oneapm
+        if self._oa_serial
+          self._oa_header_str
+        else
+          # Since we didn't install a header callback for a non-serial request,
+          # just fall back to the original implementation.
+          header_str_without_oneapm
+        end
+      end
+
+      alias_method :header_str_without_oneapm, :header_str
+      alias_method :header_str, :header_str_with_oneapm
+    end # class Curl::Easy
+
+
+    class Curl::Multi
+      include OneApm::Support::MethodTracer
+
+      # Add CAT with callbacks if the request is serial
+      def add_with_oneapm(curl) #THREAD_LOCAL_ACCESS
+        if curl.respond_to?(:_oa_serial) && curl._oa_serial
+          hook_pending_request(curl) if OneApm::Agent.tl_is_execution_traced?
+        end
+
+        return add_without_oneapm( curl )
+      end
+
+      alias_method :add_without_oneapm, :add
+      alias_method :add, :add_with_oneapm
+
+
+      # Trace as an External/Multiple call if the first request isn't serial.
+      def perform_with_oneapm(&blk)
+        return perform_without_oneapm if
+          self.requests.first &&
+          self.requests.first.respond_to?(:_oa_serial) &&
+          self.requests.first._oa_serial
+
+        trace_execution_scoped("External/Multiple/Curb::Multi/perform") do
+          perform_without_oneapm(&blk)
+        end
+      end
+
+      alias_method :perform_without_oneapm, :perform
+      alias_method :perform, :perform_with_oneapm
+
+
+      # Instrument the specified +request+ (a Curl::Easy object) and set up cross-application
+      # tracing if it's enabled.
+      def hook_pending_request(request) #THREAD_LOCAL_ACCESS
+        wrapped_request, wrapped_response = wrap_request(request)
+        state   = OneApm::TransactionState.tl_get
+        t0      = Time.now
+        segment = OneApm::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
+
+        unless request._oa_instrumented
+          install_header_callback(request, wrapped_response)
+          install_completion_callback(request, t0, segment, wrapped_request, wrapped_response)
+          request._oa_instrumented = true
+        end
+      rescue => err
+        OneApm::Agent.logger.error("Untrapped exception", err)
+      end
+
+
+      # Create request and response adapter objects for the specified +request+
+      def wrap_request(request)
+        return OneApm::Support::HTTPClients::CurbRequest.new(request),
+               OneApm::Support::HTTPClients::CurbResponse.new(request)
+      end
+
+
+      # Install a callback that will record the response headers to enable
+      # CAT linking
+      def install_header_callback( request, wrapped_response )
+        original_callback = request.on_header
+        request._oa_original_on_header = original_callback
+        request._oa_header_str = ''
+        request.on_header do |header_data|
+          wrapped_response.append_header_data( header_data )
+
+          if original_callback
+            original_callback.call( header_data )
+          else
+            header_data.length
+          end
+        end
+      end
+
+      # Install a callback that will finish the trace.
+      def install_completion_callback(request, t0, segment, wrapped_request, wrapped_response) #THREAD_LOCAL_ACCESS
+        original_callback = request.on_complete
+        request._oa_original_on_complete = original_callback
+        request.on_complete do |finished_request|
+          begin
+            state = OneApm::TransactionState.tl_get
+            OneApm::Agent::CrossAppTracing.finish_trace(state, t0, segment, wrapped_request, wrapped_response)
+          ensure
+            # Make sure the existing completion callback is run, and restore the
+            # on_complete callback to how it was before.
+            original_callback.call(finished_request) if original_callback
+            remove_instrumentation_callbacks(request)
+          end
+        end
+      end
+
+      def remove_instrumentation_callbacks(request)
+        request.on_complete(&request._oa_original_on_complete)
+        request.on_header(&request._oa_original_on_header)
+        request._oa_instrumented = false
+      end
+
+    end # class Curl::Multi
+
+  end
+end

data/lib/one_apm/inst/http_clients/excon.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  named :excon
+
+  # We have two ways of instrumenting Excon:
+  # - For newer versions, use the middleware mechanism Excon exposes
+  # - For older versions, monkey-patch Excon::Connection#request
+  #
+  # EXCON_MINIMUM_VERSION is the minimum version we attempt to instrument at all.
+  # EXCON_MIDDLEWARE_MINIMUM_VERSION is the min version we use the newer
+  #   instrumentation for.
+  #
+  # Note that middlewares were added to Excon prior to 0.19, but we don't
+  # use middleware-based instrumentation prior to that version because it didn't
+  # expose a way for middlewares to know about request failures.
+  #
+  # Why don't we use Excon.defaults[:instrumentor]?
+  # While this might seem a perfect fit, it unfortunately isn't suitable in
+  # current form. Someone might reasonably set the default instrumentor to
+  # something else after we install our instrumentation. Ideally, excon would
+  # itself conform to the #subscribe interface of ActiveSupport::Notifications,
+  # so we could safely subscribe and not be clobbered by future subscribers,
+  # but alas, it does not yet.
+
+  EXCON_MINIMUM_VERSION = ::OneApm::VersionNumber.new("0.10.1")
+  EXCON_MIDDLEWARE_MINIMUM_VERSION = ::OneApm::VersionNumber.new("0.19.0")
+
+  depends_on do
+    defined?(::Excon) && defined?(::Excon::VERSION)
+  end
+
+  executes do
+    excon_version = OneApm::VersionNumber.new(::Excon::VERSION)
+    if excon_version >= EXCON_MINIMUM_VERSION
+      install_excon_instrumentation(excon_version)
+    else
+      ::OneApm::Agent.logger.warn("Excon instrumentation requires at least version #{EXCON_MINIMUM_VERSION}")
+    end
+  end
+
+  def install_excon_instrumentation(excon_version)
+    require 'one_apm/agent/cross_app/cross_app_tracing'
+    require 'one_apm/support/http_clients/excon_wrappers'
+
+    if excon_version >= EXCON_MIDDLEWARE_MINIMUM_VERSION
+      install_middleware_excon_instrumentation
+    else
+      install_legacy_excon_instrumentation
+    end
+  end
+
+  def install_middleware_excon_instrumentation
+    ::OneApm::Agent.logger.info 'Installing middleware-based Excon instrumentation'
+    require 'one_apm/inst/http_clients/excon/middleware'
+    defaults = Excon.defaults
+
+    if defaults[:middlewares]
+      defaults[:middlewares] << ::Excon::Middleware::OneApmCrossAppTracing
+    else
+      ::OneApm::Agent.logger.warn("Did not find :middlewares key in Excon.defaults, skipping Excon instrumentation")
+    end
+  end
+
+  def install_legacy_excon_instrumentation
+    ::OneApm::Agent.logger.info 'Installing legacy Excon instrumentation'
+    require 'one_apm/inst/http_clients/excon/connection'
+    ::Excon::Connection.install_oneapm_instrumentation
+  end
+end

data/lib/one_apm/inst/http_clients/excon/connection.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module ::Excon
+  class Connection
+    def oneapm_connection_params
+      (@connection || @data)
+    end
+
+    def oneapm_resolved_request_params(request_params)
+      resolved = oneapm_connection_params.merge(request_params)
+      resolved[:headers] = resolved[:headers].merge(request_params[:headers] || {})
+      resolved
+    end
+
+    def request_with_oneapm_trace(params, &block)
+      orig_response = nil
+      resolved_params = oneapm_resolved_request_params(params)
+      wrapped_request = ::OneApm::Support::HTTPClients::ExconHTTPRequest.new(resolved_params)
+      ::OneApm::Agent::CrossAppTracing.tl_trace_http_request(wrapped_request) do
+        orig_response = request_without_oneapm_trace(resolved_params, &block)
+        ::OneApm::Support::HTTPClients::ExconHTTPResponse.new(orig_response)
+      end
+      orig_response
+    end
+
+    def self.install_oneapm_instrumentation
+      alias request_without_oneapm_trace request
+      alias request request_with_oneapm_trace
+    end
+  end
+end

data/lib/one_apm/inst/http_clients/excon/middleware.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module ::Excon
+  module Middleware
+    class OneApmCrossAppTracing
+      TRACE_DATA_IVAR = :@oneapm_trace_data
+
+      def initialize(stack)
+        @stack = stack
+      end
+
+      def request_call(datum) #THREAD_LOCAL_ACCESS
+        begin
+          # Only instrument this request if we haven't already done so, because
+          # we can get request_call multiple times for requests marked as
+          # :idempotent in the options, but there will be only a single
+          # accompanying response_call/error_call.
+          if datum[:connection] && !datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
+            wrapped_request = ::OneApm::Support::HTTPClients::ExconHTTPRequest.new(datum)
+            state   = ::OneApm::TransactionState.tl_get
+            t0      = Time.now
+            segment = ::OneApm::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
+            datum[:connection].instance_variable_set(TRACE_DATA_IVAR, [t0, segment, wrapped_request])
+          end
+        rescue => e
+          OneApm::Agent.logger.debug(e)
+        end
+        @stack.request_call(datum)
+      end
+
+      def response_call(datum)
+        finish_trace(datum)
+        @stack.response_call(datum)
+      end
+
+      def error_call(datum)
+        finish_trace(datum)
+        @stack.error_call(datum)
+      end
+
+      def finish_trace(datum) #THREAD_LOCAL_ACCESS
+        trace_data = datum[:connection] && datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
+        if trace_data
+          datum[:connection].instance_variable_set(TRACE_DATA_IVAR, nil)
+          t0, segment, wrapped_request = trace_data
+          if datum[:response]
+            wrapped_response = ::OneApm::Support::HTTPClients::ExconHTTPResponse.new(datum[:response])
+          end
+          state = ::OneApm::TransactionState.tl_get
+          ::OneApm::Agent::CrossAppTracing.finish_trace(state, t0, segment, wrapped_request, wrapped_response)
+        end
+      end
+    end
+  end
+end