oneapm_rpm 1.1.0

data/lib/one_apm/frameworks/external.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'one_apm/frameworks/ruby'
+
+module OneApm
+  class Probe
+    module Frameworks
+      class External < OneApm::Probe::Frameworks::Ruby
+        def init_config(options={})
+          super
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/frameworks/rails.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+require 'one_apm/frameworks/ruby'
+
+module OneApm
+  class Probe
+    module Frameworks
+      class Rails < OneApm::Probe::Frameworks::Ruby
+
+        def env
+          @env ||= RAILS_ENV.dup
+        end
+
+        # Rails can return an empty string from this method, causing
+        # the agent not to start even when it is properly in a rails 3
+        # application, so we test the value to make sure it actually
+        # has contents, and bail to the parent class if it is empty.
+        def root
+          root = rails_root.to_s
+          if !root.empty?
+            root
+          else
+            super
+          end
+        end
+
+        def rails_root
+          RAILS_ROOT if defined?(RAILS_ROOT)
+        end
+
+        def rails_config
+          if defined?(::Rails) && ::Rails.respond_to?(:configuration)
+            ::Rails.configuration
+          else
+            @config
+          end
+        end
+
+        # In versions of Rails prior to 2.0, the rails config was only available to
+        # the init.rb, so it had to be passed on from there.  This is a best effort to
+        # find a config and use that.
+        def init_config(options={})
+          @config = options[:config]
+
+          if rails_config && ::Rails.configuration.respond_to?(:after_initialize)
+            rails_config.after_initialize do
+              # This will insure we load all the instrumentation as late as possible.
+              LibraryDetection.detect!
+            end
+          end
+
+          if !Agent.config[:agent_enabled]
+            # Might not be running if it does not think mongrel, thin, passenger, etc
+            # is running, if it thinks it's a rake task, or if the agent_enabled is false.
+            ::OneApm::Agent.logger.info("OneApm Agent not running.")
+          else
+            install_browser_monitoring(rails_config)
+            install_agent_hooks(rails_config)
+          end
+        end
+
+        def install_agent_hooks(config)
+          return if @agent_hooks_installed
+          @agent_hooks_installed = true
+          return if config.nil? || !config.respond_to?(:middleware)
+          begin
+            require 'one_apm/rack/middleware_hooks'
+            return unless OneApm::Rack::MiddlewareHooks.needed?
+            config.middleware.use OneApm::Rack::MiddlewareHooks
+            ::OneApm::Agent.logger.debug("Installed OneApm Agent Hooks middleware")
+          rescue => e
+            ::OneApm::Agent.logger.warn("Error installing OneApm Agent Hooks middleware", e)
+          end
+        end
+
+        def install_browser_monitoring(config)
+          return if @browser_monitoring_installed
+          @browser_monitoring_installed = true
+          return if config.nil? || !config.respond_to?(:middleware) || !Agent.config[:'browser_monitoring.auto_instrument']
+          begin
+            require 'one_apm/rack/browser_monitoring'
+            config.middleware.use OneApm::Rack::BrowserMonitoring
+            ::OneApm::Agent.logger.debug("Installed OneApm Browser Monitoring middleware")
+          rescue => e
+            ::OneApm::Agent.logger.warn("Error installing OneApm Browser Monitoring middleware", e)
+          end
+        end
+
+        protected
+
+        def install_shim
+          super
+          require 'one_apm/inst/transaction_base'
+          if ActiveSupport.respond_to?(:on_load) # rails 3+
+            ActiveSupport.on_load(:action_controller) { include OneApm::Agent::Instrumentation::TransactionBase::Shim }
+          else
+            ActionController::Base.class_eval { include OneApm::Agent::Instrumentation::TransactionBase::Shim }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/frameworks/rails3.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'one_apm/frameworks/rails'
+
+module OneApm
+  class Probe
+    module Frameworks
+      class Rails3 < OneApm::Probe::Frameworks::Rails
+
+        def env
+          @env ||= ::Rails.env.to_s
+        end
+
+        def rails_root
+          ::Rails.root.to_s
+        end
+
+        def vendor_root
+          @vendor_root ||= File.join(root,'vendor','rails')
+        end
+
+        def version
+          @rails_version ||= OneApm::VersionNumber.new(::Rails::VERSION::STRING)
+        end
+
+        protected
+
+        def install_shim
+          super
+          ActiveSupport.on_load(:action_controller) do
+            include OneApm::Agent::Instrumentation::TransactionBase::Shim
+          end
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/frameworks/rails4.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'one_apm/frameworks/rails3'
+
+module OneApm
+  class Probe
+    module Frameworks
+      class Rails4 < OneApm::Probe::Frameworks::Rails3
+        def rails_gem_list
+          Bundler.rubygems.all_specs.map do |gem|
+            "#{gem.name} (#{gem.version})"
+          end
+        end
+
+        def append_plugin_list
+          # Rails 4 does not allow plugins
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/frameworks/ruby.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module OneApm
+  class Probe
+    module Frameworks
+      class Ruby < OneApm::Probe
+        def env
+          @env ||= ENV['ONE_APM_ENV'] || ENV['RUBY_ENV'] ||
+                   ENV['RAILS_ENV']   || ENV['RACK_ENV'] || 'development'
+        end
+
+        def root
+          @root ||= ENV['APP_ROOT'] || '.'
+        end
+
+        def init_config(options={})
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/frameworks/sinatra.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'one_apm/frameworks/ruby'
+
+module OneApm
+  class Probe
+    module Frameworks
+      class Sinatra < OneApm::Probe::Frameworks::Ruby
+      end
+    end
+  end
+end

data/lib/one_apm/inst/3rd/active_merchant.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  @name = :active_merchant
+
+  depends_on do
+    defined?(ActiveMerchant) && defined?(ActiveMerchant::Billing) &&
+      defined?(ActiveMerchant::Billing::Gateway) &&
+      ActiveMerchant::Billing::Gateway.respond_to?(:implementations)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing ActiveMerchant instrumentation'
+  end
+
+  executes do
+    class ActiveMerchant::Billing::Gateway
+      include OneApm::Support::MethodTracer
+    end
+
+    ActiveMerchant::Billing::Gateway.implementations.each do |gateway|
+      gateway.class_eval do
+        implemented_methods = public_instance_methods(false).map(&:to_sym)
+        gateway_name = self.name.split('::').last
+        [:authorize, :purchase, :credit, :void, :capture, :recurring, :store, :unstore, :update].each do |operation|
+          if implemented_methods.include?(operation)
+            add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}/#{operation}"
+            add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}", :push_scope => false
+            add_method_tracer operation, "ActiveMerchant/operation/#{operation}", :push_scope => false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/inst/3rd/acts_as_solr.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+module OneApm
+  module Instrumentation
+    module ActsAsSolrInstrumentation
+      module ParserMethodsInstrumentation
+        def parse_query_with_oneapm(*args)
+          self.class.trace_execution_scoped(["SolrClient/ActsAsSolr/query"]) do
+            t0 = Time.now
+            begin
+              parse_query_without_oneapm(*args)
+            ensure
+              OneApm::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect, (Time.now - t0).to_f) rescue nil
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+LibraryDetection.defer do
+  @name = :acts_as_solr
+
+  depends_on do
+    defined?(ActsAsSolr)
+  end
+
+  depends_on do
+    defined?(ActsAsSolr::ParserMethods)
+  end
+
+  depends_on do
+    defined?(ActsAsSolr::ClassMethods)
+  end
+
+  depends_on do
+    defined?(ActsAsSolr::CommonMethods)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing ActsAsSolr instrumentation'
+  end
+
+  executes do
+    ActsAsSolr::ParserMethods.module_eval do
+      include OneApm::Instrumentation::ActsAsSolrInstrumentation::ParserMethodsInstrumentation
+      alias :parse_query_without_oneapm :parse_query
+      alias :parse_query :parse_query_with_oneapm
+    end
+  end
+
+  executes do
+    ActsAsSolr::ClassMethods.module_eval do
+      %w[find_by_solr find_id_by_solr multi_solr_search count_by_solr].each do |method|
+        add_method_tracer method, 'SolrClient/ActsAsSolr/query'
+      end
+      add_method_tracer :rebuild_solr_index, 'SolrClient/ActsAsSolr/index'
+    end
+  end
+
+  executes do
+    ActsAsSolr::CommonMethods.module_eval do
+      add_method_tracer :solr_add, 'SolrClient/ActsAsSolr/add'
+      add_method_tracer :solr_delete, 'SolrClient/ActsAsSolr/delete'
+      add_method_tracer :solr_commit, 'SolrClient/ActsAsSolr/commit'
+      add_method_tracer :solr_optimize, 'SolrClient/ActsAsSolr/optimize'
+    end
+  end
+end

data/lib/one_apm/inst/3rd/authlogic.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  @name = :authlogic
+
+  depends_on do
+    defined?(Authlogic) &&
+      defined?(Authlogic::Session) &&
+      defined?(Authlogic::Session::Base)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Authlogic instrumentation'
+  end
+
+  executes do
+    Authlogic::Session::Base.class_eval do
+      class << self
+        add_method_tracer :find, 'Custom/Authlogic/find'
+      end
+    end
+  end
+end

data/lib/one_apm/inst/3rd/sunspot.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  @name = :sunspot
+
+  depends_on do
+    defined?(::Sunspot)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Rails Sunspot instrumentation'
+  end
+
+  executes do
+    ::Sunspot.module_eval do
+      class << self
+        %w(index index!).each do |method|
+          add_method_tracer method, 'SolrClient/Sunspot/index'
+        end
+        add_method_tracer :commit, 'SolrClient/Sunspot/commit'
+
+        %w[search more_like_this].each do |method|
+          add_method_tracer method, 'SolrClient/Sunspot/query'
+        end
+        %w[remove remove! remove_by_id remove_by_id! remove_all remove_all!].each do |method|
+          add_method_tracer method, 'SolrClient/Sunspot/delete'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  named :activejob
+
+  depends_on do
+    defined?(::ActiveJob::Base)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing ActiveJob instrumentation'
+
+    ::ActiveJob::Base.around_enqueue do |job, block|
+      ::OneApm::Agent::Instrumentation::ActiveJobHelper.enqueue(job, block)
+    end
+
+    ::ActiveJob::Base.around_perform do |job, block|
+      ::OneApm::Agent::Instrumentation::ActiveJobHelper.perform(job, block)
+    end
+  end
+end
+
+module OneApm
+  module Agent
+    module Instrumentation
+      module ActiveJobHelper
+        include ::OneApm::Support::MethodTracer
+
+        def self.enqueue(job, block)
+          run_in_trace(job, block, :Produce)
+        end
+
+        def self.perform(job, block)
+          state = ::OneApm::TransactionState.tl_get
+
+          # Don't nest transactions if we're already in a web transaction.
+          # Probably inline processing the job if that happens, so just trace.
+          if state.in_web_transaction?
+            run_in_trace(job, block, :Consume)
+          elsif state.in_background_transaction?
+            ::OneApm::Transaction.set_default_transaction_name(
+              transaction_name_suffix_for_job(job),
+              transaction_category)
+            block.call
+          else
+            run_in_transaction(state, job, block)
+          end
+        end
+
+        def self.run_in_trace(job, block, event)
+          trace_execution_scoped("MessageBroker/#{adapter}/Queue/#{event}/Named/#{job.queue_name}") do
+            block.call
+          end
+        end
+
+        def self.run_in_transaction(state, job, block)
+          ::OneApm::Transaction.wrap(state,
+                                              transaction_name_for_job(job),
+                                              :other,
+                                              &block)
+        end
+
+        def self.transaction_category
+          "OtherTransaction/#{adapter}"
+        end
+
+        def self.transaction_name_suffix_for_job(job)
+          "#{job.class}/execute"
+        end
+
+        def self.transaction_name_for_job(job)
+          "#{transaction_category}/#{transaction_name_suffix_for_job(job)}"
+        end
+
+        def self.adapter
+          clean_adapter_name(::ActiveJob::Base.queue_adapter.name)
+        end
+
+        ADAPTER_REGEX = /ActiveJob::QueueAdapters::(.*)Adapter/
+
+        def self.clean_adapter_name(name)
+          name = "ActiveJob::#{$1}" if ADAPTER_REGEX =~ name
+          name
+        end
+      end
+    end
+  end
+end