oneapm_rpm 1.1.0

data/lib/one_apm/inst/background_job/delayed_job.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  @name = :delayed_job
+
+  depends_on do
+    !OneApm::Agent.config[:disable_dj]
+  end
+
+  depends_on do
+    defined?(::Delayed) && defined?(::Delayed::Worker) && !OneApm::Agent.config[:disable_dj]
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing DelayedJob instrumentation [part 1/2]'
+  end
+
+  executes do
+    Delayed::Worker.class_eval do
+      def initialize_with_one_apm(*args)
+        initialize_without_one_apm(*args)
+        worker_name = case
+                      when self.respond_to?(:name) then self.name
+                      when self.class.respond_to?(:default_name) then self.class.default_name
+                      end
+        OneApm::DelayedJobInjection.worker_name = worker_name
+
+        if defined?(::Delayed::Job) && ::Delayed::Job.method_defined?(:invoke_job)
+          ::OneApm::Agent.logger.info 'Installing DelayedJob instrumentation [part 2/2]'
+          install_oneapm_job_tracer
+          OneApm::Probe.instance.init_plugin :dispatcher => :delayed_job
+        else
+          OneApm::Agent.logger.warn("Did not find a Delayed::Job class responding to invoke_job, aborting DJ instrumentation")
+        end
+      end
+
+      alias initialize_without_one_apm initialize
+      alias initialize initialize_with_one_apm
+
+      def install_oneapm_job_tracer
+        Delayed::Job.class_eval do
+          include OneApm::Agent::Instrumentation::TransactionBase
+          if self.instance_methods.include?('name') || self.instance_methods.include?(:name)
+            add_transaction_tracer "invoke_job", :category => 'OtherTransaction/DelayedJob', :path => '#{self.name}'
+          else
+            add_transaction_tracer "invoke_job", :category => 'OtherTransaction/DelayedJob'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/inst/background_job/delayed_job_injection.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+module OneApm
+  module DelayedJobInjection
+    extend self
+    attr_accessor :worker_name
+  end
+end

data/lib/one_apm/inst/background_job/resque.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  @name = :resque
+
+  depends_on do
+    defined?(::Resque::Job) && !OneApm::Agent.config[:disable_resque]  &&
+      !OneApm::LanguageSupport.using_version?('1.9.1')
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Resque instrumentation'
+  end
+
+  executes do
+    module Resque
+      module Plugins
+        module OneApmInstrumentation
+          include OneApm::Agent::Instrumentation::TransactionBase
+
+          def around_perform_with_monitoring(*args)
+            begin
+              perform_action_with_oneapm_trace(
+                :name => 'perform',
+                :class_name => self.name,
+                :category => 'OtherTransaction/ResqueJob') do
+
+                if OneApm::Agent.config[:'resque.capture_params']
+                  OneApm::Agent.add_custom_parameters(:job_arguments => args)
+                end
+
+                yield(*args)
+              end
+            ensure
+              OneApm::Agent.instance.flush_pipe_data
+            end
+          end
+        end
+      end
+    end
+
+    module OneApm
+      module Agent
+        module Instrumentation
+          module ResqueInstrumentationInstaller
+            def payload_class
+              klass = super
+              klass.instance_eval do
+                extend ::Resque::Plugins::OneApmInstrumentation
+              end
+            end
+          end
+        end
+      end
+    end
+
+    ::Resque::Job.class_eval do
+      def self.new(*args)
+        super(*args).extend OneApm::Agent::Instrumentation::ResqueInstrumentationInstaller
+      end
+    end
+
+    if OneApm::LanguageSupport.can_fork?
+      # Resque::Worker#fork isn't around in Resque 2.x
+      if OneApm::VersionNumber.new(::Resque::VERSION) < OneApm::VersionNumber.new("2.0.0")
+        ::Resque::Worker.class_eval do
+          if OneApm::Agent.config[:'resque.use_harvest_lock']
+            ::OneApm::Agent.logger.info 'Installing Resque harvest/fork synchronization'
+            def fork_with_oneapm(*args, &block)
+              OneApm::Agent.instance.synchronize_with_harvest do
+                fork_without_oneapm(*args, &block)
+
+                # Reached in parent, not expected in the child since Resque
+                # uses the block form of fork
+              end
+            end
+
+            alias_method :fork_without_oneapm, :fork
+            alias_method :fork, :fork_with_oneapm
+          end
+        end
+      end
+
+      ::Resque.before_first_fork do
+        OneApm::Agent.start(:dispatcher   => :resque,
+                                     :sync_startup => true,
+                                     :start_channel_listener => true)
+      end
+
+      ::Resque.before_fork do |job|
+        if ENV['FORK_PER_JOB'] != 'false'
+          OneApm::Agent::PipeChannelManager.register_report_channel(job.object_id)
+        end
+      end
+
+      ::Resque.after_fork do |job|
+        # Only suppress reporting Instance/Busy for forked children
+        # Traced errors UI relies on having the parent process report that metric
+        OneApm::Agent.instance.after_fork(:report_to_channel => job.object_id,
+                                   :report_instance_busy => false)
+      end
+    end
+  end
+end
+
+# call this now so it is memoized before potentially forking worker processes
+OneApm::LanguageSupport.can_fork?

data/lib/one_apm/inst/background_job/sidekiq.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  @name = :sidekiq
+
+  depends_on do
+    defined?(::Sidekiq) && !OneApm::Agent.config[:disable_sidekiq]
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Sidekiq instrumentation'
+  end
+
+  executes do
+    class OneApm::SidekiqInstrumentation
+      include OneApm::Agent::Instrumentation::TransactionBase
+
+      # Client middleware has additional parameters, and our tests use the
+      # middleware client-side to work inline.
+      def call(worker, msg, queue, *_)
+        trace_args = if worker.respond_to?(:oneapm_trace_args)
+          worker.oneapm_trace_args(msg, queue)
+        else
+          self.class.default_trace_args(msg)
+        end
+
+        perform_action_with_oneapm_trace(trace_args) do
+          if OneApm::Agent.config[:'sidekiq.capture_params']
+            OneApm::Agent.add_custom_parameters(:job_arguments => msg['args'])
+          end
+          yield
+        end
+      end
+
+      def self.default_trace_args(msg)
+        {
+          :name => 'perform',
+          :class_name => msg['class'],
+          :category => 'OtherTransaction/SidekiqJob'
+        }
+      end
+    end
+
+    class Sidekiq::Extensions::DelayedClass
+      def oneapm_trace_args(msg, queue)
+        (target, method_name, _args) = YAML.load(msg['args'][0])
+        {
+          :name => method_name,
+          :class_name => target.name,
+          :category => 'OtherTransaction/SidekiqJob'
+        }
+      rescue => e
+        OneApm::Agent.logger.error("Failure during deserializing YAML for Sidekiq::Extensions::DelayedClass", e)
+        OneApm::SidekiqInstrumentation.default_trace_args(msg)
+      end
+    end
+
+    Sidekiq.configure_server do |config|
+      config.server_middleware do |chain|
+        chain.add OneApm::SidekiqInstrumentation
+      end
+    end
+  end
+end

data/lib/one_apm/inst/dispatcher/passenger.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  @name = :passenger
+
+  depends_on do
+    defined?(::PhusionPassenger)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.debug "Installing Passenger event hooks."
+
+    ::PhusionPassenger.on_event(:stopping_worker_process) do
+      ::OneApm::Agent.logger.debug "Passenger stopping this process, shutdown the agent."
+      OneApm::Agent.instance.shutdown
+    end
+
+    ::PhusionPassenger.on_event(:starting_worker_process) do |forked|
+      # We want to reset the stats from the stats engine in case any carried
+      # over into the spawned process.  Don't clear them in case any were
+      # cached.  We do this even in conservative spawning.
+      OneApm::Agent.instance.after_fork(:force_reconnect => true)
+    end
+  end
+end

data/lib/one_apm/inst/dispatcher/rainbows.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  @name = :rainbows
+
+  depends_on do
+    defined?(::Rainbows) && defined?(::Rainbows::HttpServer)
+  end
+
+  executes do
+    OneApm::Agent.logger.info 'Installing Rainbows instrumentation'
+  end
+
+  executes do
+    Rainbows::HttpServer.class_eval do
+      old_worker_loop = instance_method(:worker_loop)
+      define_method(:worker_loop) do |worker|
+        OneApm::Agent.instance.after_fork(:force_reconnect => true)
+        old_worker_loop.bind(self).call(worker)
+      end
+    end
+  end
+end

data/lib/one_apm/inst/framework/grape.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+
+require 'one_apm/support/parameter_filtering'
+
+module OneApm
+  module Agent
+    module Instrumentation
+      module Grape
+        extend self
+
+        API_ENDPOINT   = 'api.endpoint'.freeze
+        FORMAT_REGEX   = /\(\/?\.:format\)/.freeze
+        VERSION_REGEX  = /:version(\/|$)/.freeze
+        EMPTY_STRING   = ''.freeze
+        MIN_VERSION    = VersionNumber.new("0.2.0")
+
+        def handle_transaction(endpoint, class_name)
+          return unless endpoint && route = endpoint.route
+          name_transaction(route, class_name)
+          capture_params(endpoint) if Agent.config[:capture_params]
+        end
+
+        def name_transaction(route, class_name)
+          txn_name = name_for_transaction(route, class_name)
+          segment_name = "Middleware/Grape/#{class_name}/call"
+          Transaction.set_default_transaction_name(txn_name, :grape, segment_name)
+        end
+
+        def name_for_transaction(route, class_name)
+          action_name = route.route_path.sub(FORMAT_REGEX, EMPTY_STRING)
+          method_name = route.route_method
+
+          if route.route_version
+            action_name = action_name.sub(VERSION_REGEX, EMPTY_STRING)
+            "#{class_name}-#{route.route_version}#{action_name} (#{method_name})"
+          else
+            "#{class_name}#{action_name} (#{method_name})"
+          end
+        end
+
+        def capture_params(endpoint)
+          txn = Transaction.tl_current
+          env = endpoint.request.env
+          params = OneApm::Support::ParameterFiltering::apply_filters(env, endpoint.params)
+          params.delete("route_info")
+          txn.filtered_params = params
+        end
+      end
+    end
+  end
+end
+
+LibraryDetection.defer do
+  # Why not just :grape? oneapm-grape used that name already, and while we're
+  # not shipping yet, overloading the name interferes with the plugin.
+  named :grape
+
+  depends_on do
+    ::OneApm::Agent.config[:disable_grape] == false
+  end
+
+  depends_on do
+    defined?(::Grape::VERSION) &&
+      ::OneApm::VersionNumber.new(::Grape::VERSION) >= ::OneApm::Agent::Instrumentation::Grape::MIN_VERSION
+  end
+
+  executes do
+    OneApm::Agent.logger.info 'Installing Grape instrumentation'
+    instrument_call
+  end
+
+  def instrument_call
+    ::Grape::API.class_eval do
+      def call_with_one_apm(env)
+        begin
+          response = call_without_one_apm(env)
+        ensure
+          begin
+            endpoint = env[::OneApm::Agent::Instrumentation::Grape::API_ENDPOINT]
+            ::OneApm::Agent::Instrumentation::Grape.handle_transaction(endpoint, self.class.name)
+          rescue => e
+            ::OneApm::Agent.logger.warn("Error in Grape instrumentation", e)
+          end
+        end
+
+        response
+      end
+
+      alias_method :call_without_one_apm, :call
+      alias_method :call, :call_with_one_apm
+    end
+  end
+
+end

data/lib/one_apm/inst/framework/padrino.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'one_apm/inst/framework/sinatra'
+
+LibraryDetection.defer do
+  @name = :padrino
+
+  depends_on do
+    !OneApm::Agent.config[:disable_sinatra] &&
+      defined?(::Padrino) && defined?(::Padrino::Routing::InstanceMethods)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Padrino instrumentation'
+
+    # Our Padrino instrumentation relies heavily on the fact that Padrino is
+    # built on Sinatra. Although it wires up a lot of its own routing logic,
+    # we only need to patch into Padrino's dispatch to get things started.
+    #
+    # Parts of the Sinatra instrumentation (such as the TransactionNamer) are
+    # aware of Padrino as a potential target in areas where both Sinatra and
+    # Padrino run through the same code.
+    module ::Padrino::Routing::InstanceMethods
+      include OneApm::Agent::Instrumentation::Sinatra
+
+      alias dispatch_without_oneapm dispatch!
+      alias dispatch! dispatch_with_oneapm
+    end
+  end
+end

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

@@ -0,0 +1,185 @@
+# encoding: utf-8
+
+require 'one_apm/inst/transaction_base'
+require 'one_apm/inst/framework/sinatra/transaction_namer'
+require 'one_apm/inst/framework/sinatra/ignorer'
+
+LibraryDetection.defer do
+  @name = :sinatra
+
+  depends_on do
+    !OneApm::Agent.config[:disable_sinatra] &&
+      defined?(::Sinatra) && defined?(::Sinatra::Base) &&
+      Sinatra::Base.private_method_defined?(:dispatch!) &&
+      Sinatra::Base.private_method_defined?(:process_route) &&
+      Sinatra::Base.private_method_defined?(:route_eval)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Sinatra instrumentation'
+  end
+
+  executes do
+    ::Sinatra::Base.class_eval do
+      include OneApm::Agent::Instrumentation::Sinatra
+
+      alias dispatch_without_oneapm dispatch!
+      alias dispatch! dispatch_with_oneapm
+
+      alias process_route_without_oneapm process_route
+      alias process_route process_route_with_oneapm
+
+      alias route_eval_without_oneapm route_eval
+      alias route_eval route_eval_with_oneapm
+
+      register OneApm::Agent::Instrumentation::Sinatra::Ignorer
+    end
+
+    module ::Sinatra
+      register OneApm::Agent::Instrumentation::Sinatra::Ignorer
+    end
+  end
+
+  executes do
+    if Sinatra::Base.respond_to?(:build)
+      # These requires are inside an executes block because they require rack, and
+      # we can't be sure that rack is available when this file is first required.
+      require 'one_apm/rack/middleware_hooks'
+      require 'one_apm/rack/browser_monitoring'
+
+      ::Sinatra::Base.class_eval do
+        class << self
+          alias build_without_oneapm build
+          alias build build_with_oneapm
+        end
+      end
+    else
+      ::OneApm::Agent.logger.info("Skipping auto-injection of middleware for Sinatra - requires Sinatra 1.2.1+")
+    end
+  end
+end
+
+module OneApm
+  module Agent
+    module Instrumentation
+      # OneApm instrumentation for Sinatra applications.  Sinatra actions will
+      # appear in the UI similar to controller actions, and have breakdown charts
+      # and transaction traces.
+      #
+      # The actions in the UI will correspond to the pattern expression used
+      # to match them, not directly to full URL's.
+      module Sinatra
+        include ::OneApm::Agent::Instrumentation::TransactionBase
+
+        # Expected method for supporting TransactionBase
+        def oneapm_request_headers(_)
+          request.env
+        end
+
+        def self.included(clazz)
+          clazz.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def oneapm_middlewares
+            middlewares = [OneApm::Rack::BrowserMonitoring]
+            if OneApm::Rack::MiddlewareHooks.needed?
+              middlewares << OneApm::Rack::MiddlewareHooks
+            end
+            middlewares
+          end
+
+          def build_with_oneapm(*args, &block)
+            unless OneApm::Agent.config[:disable_sinatra_auto_middleware]
+              oneapm_middlewares.each do |middleware_class|
+                try_to_use(self, middleware_class)
+              end
+            end
+            build_without_oneapm(*args, &block)
+          end
+
+          def try_to_use(app, clazz)
+            has_middleware = app.middleware.any? { |info| info[0] == clazz }
+            app.use(clazz) unless has_middleware
+          end
+        end
+
+        # Capture last route we've seen. Will set for transaction on route_eval
+        def process_route_with_oneapm(*args, &block)
+          begin
+            env["oneapm.last_route"] = args[0]
+          rescue => e
+            ::OneApm::Agent.logger.debug("Failed determining last route in Sinatra", e)
+          end
+
+          process_route_without_oneapm(*args, &block)
+        end
+
+        # If a transaction name is already set, this call will tromple over it.
+        # This is intentional, as typically passing to a separate route is like
+        # an entirely separate transaction, so we pick up the new name.
+        #
+        # If we're ignored, this remains safe, since set_transaction_name
+        # care for the gating on the transaction's existence for us.
+        def route_eval_with_oneapm(*args, &block)
+          begin
+            txn_name = TransactionNamer.transaction_name_for_route(env, request)
+            unless txn_name.nil?
+              ::OneApm::Transaction.set_default_transaction_name(
+                "#{self.class.name}/#{txn_name}", :sinatra)
+            end
+          rescue => e
+            ::OneApm::Agent.logger.debug("Failed during route_eval to set transaction name", e)
+          end
+
+          route_eval_without_oneapm(*args, &block)
+        end
+
+        def dispatch_with_oneapm #THREAD_LOCAL_ACCESS
+          request_params = get_request_params
+          filtered_params = OneApm::Support::ParameterFiltering::apply_filters(request.env, request_params || {})
+
+          name = TransactionNamer.initial_transaction_name(request)
+          perform_action_with_oneapm_trace(:category => :sinatra,
+                                             :name => name,
+                                             :params => filtered_params) do
+            dispatch_and_notice_errors_with_oneapm
+          end
+        end
+
+        def get_request_params
+          begin
+            @request.params
+          rescue => e
+            OneApm::Agent.logger.debug("Failed to get params from Rack request.", e)
+            nil
+          end
+        end
+
+        def dispatch_and_notice_errors_with_oneapm
+          dispatch_without_oneapm
+        ensure
+          # Will only see an error raised if :show_exceptions is true, but
+          # will always see them in the env hash if they occur
+          had_error = env.has_key?('sinatra.error')
+          ::OneApm::Agent.notice_error(env['sinatra.error']) if had_error
+        end
+
+        def do_not_trace?
+          Ignorer.should_ignore?(self, :routes)
+        end
+
+        # Overrides TransactionBase implementation
+        def ignore_apdex?
+          Ignorer.should_ignore?(self, :apdex)
+        end
+
+        # Overrides TransactionBase implementation
+        def ignore_enduser?
+          Ignorer.should_ignore?(self, :enduser)
+        end
+
+      end
+    end
+  end
+end