oneapm_rpm 1.1.0

data/lib/one_apm/inst/nosql/redis.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+require 'one_apm/support/method_tracer'
+
+LibraryDetection.defer do
+  @name = :redis
+
+  depends_on do
+    defined?(::Redis) && !OneApm::Agent.config[:disable_redis]
+  end
+
+  executes do
+    OneApm::Agent.logger.info 'Installing Redis Instrumentation'
+  end
+
+  executes do
+    require 'one_apm/agent/datastores'
+
+    ::Redis::Client.class_eval do
+      # Support older versions of Redis::Client that used the method
+      # +raw_call_command+.
+
+      call_method = ::Redis::Client.new.respond_to?(:call) ? :call : :raw_call_command
+
+      def call_with_oneapm_trace(*args, &blk)
+        method_name = args[0].is_a?(Array) ? args[0][0] : args[0]
+        callback = proc do |result, metric, elapsed|
+          _send_to_one_apm(args, elapsed)
+        end
+
+        OneApm::Agent::Datastores.wrap("Redis", method_name, nil, callback) do
+          call_without_oneapm_trace(*args, &blk)
+        end
+      end
+
+      alias_method :call_without_oneapm_trace, call_method
+      alias_method call_method, :call_with_oneapm_trace
+
+      # Older versions of Redis handle pipelining completely differently.
+      # Don't bother supporting them for now.
+      #
+      if public_method_defined? :call_pipelined
+        def call_pipelined_with_oneapm_trace(commands, *rest)
+          # Report each command as a metric suffixed with _pipelined, so the
+          # user can at least see what all the commands were.
+          additional = commands.map do |c|
+            name = c.kind_of?(Array) ? c[0] : c
+            "Datastore/operation/Redis/#{name.to_s.downcase}_pipelined"
+          end
+
+          callback = proc do |result, metric, elapsed|
+            _send_to_one_apm(commands, elapsed)
+            additional.each do |additional_metric|
+              OneApm::Support::MethodTracer.trace_execution_scoped(additional_metric) do
+                # No-op, just getting them as placeholders in the trace tree
+              end
+            end
+          end
+
+          OneApm::Agent::Datastores.wrap("Redis", "pipelined", nil, callback) do
+            call_pipelined_without_oneapm_trace commands, *rest
+          end
+        end
+
+        alias_method :call_pipelined_without_oneapm_trace, :call_pipelined
+        alias_method :call_pipelined, :call_pipelined_with_oneapm_trace
+      end
+
+      def _send_to_one_apm(args, elapsed)
+        if OneApm::Agent.config[:"transaction_tracer.record_sql"] == "obfuscated"
+          args.map! do |arg|
+            if arg.empty?
+              arg
+            else
+              [arg.first] + ["?"] * (arg.count - 1)
+            end
+          end
+        end
+        OneApm::Agent::Datastores.notice_statement(args.inspect, elapsed)
+      end
+    end
+  end
+end

data/lib/one_apm/inst/orm/active_record.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+require 'one_apm/agent/database/active_record_helper'
+
+module OneApm
+  module Agent
+    module Instrumentation
+      module ActiveRecord
+
+        EXPLAINER = lambda do |config, query|
+          connection = OneApm::Agent::Database.get_connection(config) do
+            ::ActiveRecord::Base.send("#{config[:adapter]}_connection", config)
+          end
+          if connection && connection.respond_to?(:execute)
+            connection.execute("EXPLAIN #{query}")
+          end
+        end
+
+        def self.insert_instrumentation
+          ::ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+            include ::OneApm::Agent::Instrumentation::ActiveRecord
+          end
+        end
+
+        def self.included(instrumented_class)
+          instrumented_class.class_eval do
+            unless instrumented_class.method_defined?(:log_without_oneapm_instrumentation)
+              alias_method :log_without_oneapm_instrumentation, :log
+              alias_method :log, :log_with_oneapm_instrumentation
+              protected :log
+            end
+          end
+        end
+
+        def log_with_oneapm_instrumentation(*args, &block) #THREAD_LOCAL_ACCESS
+          state = OneApm::TransactionState.tl_get
+
+          if !state.is_execution_traced?
+            return log_without_oneapm_instrumentation(*args, &block)
+          end
+
+          sql, name, _ = args
+          metric = ActiveRecordHelper.metric_for_name(OneApm::Helper.correctly_encoded(name)) ||
+                   ActiveRecordHelper.metric_for_sql(OneApm::Helper.correctly_encoded(sql))
+
+          if !metric
+            log_without_oneapm_instrumentation(*args, &block)
+          else
+            metrics = [metric, remote_service_metric].compact
+            metrics += ActiveRecordHelper.rollup_metrics_for(metric)
+            self.class.trace_execution_scoped(metrics) do
+              t0 = Time.now
+              begin
+                log_without_oneapm_instrumentation(*args, &block)
+              ensure
+                elapsed_time = (Time.now - t0).to_f
+                OneApm::Agent.notice_sql(sql, metric, @config, elapsed_time, state, &EXPLAINER)
+              end
+            end
+          end
+        end
+
+        def remote_service_metric
+          if @config && @config[:adapter]
+            ActiveRecordHelper.remote_service_metric(@config[:adapter], @config[:host])
+          end
+        end
+      end
+    end
+  end
+end
+
+LibraryDetection.defer do
+  @name = :active_record
+
+  depends_on do
+    defined?(::ActiveRecord) &&
+    defined?(::ActiveRecord::Base) &&
+    (!defined?(::ActiveRecord::VERSION) || ::ActiveRecord::VERSION::MAJOR.to_i <= 3)
+  end
+
+  depends_on do
+    !OneApm::Agent.config[:disable_activerecord]
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing ActiveRecord instrumentation'
+  end
+
+  executes do
+    if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
+      ActiveSupport.on_load(:active_record) do
+        ::OneApm::Agent::Instrumentation::ActiveRecord.insert_instrumentation
+      end
+    else
+      ::OneApm::Agent::Instrumentation::ActiveRecord.insert_instrumentation
+    end
+  end
+end

data/lib/one_apm/inst/orm/active_record_4.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'one_apm/inst/rails4/active_record_subscriber'
+
+LibraryDetection.defer do
+  named :active_record_4
+
+  depends_on do
+    defined?(::ActiveRecord) &&
+    defined?(::ActiveRecord::Base) &&
+    defined?(::ActiveRecord::VERSION) &&
+    ::ActiveRecord::VERSION::MAJOR.to_i >= 4
+  end
+
+  depends_on do
+    !OneApm::Agent.config[:disable_activerecord] &&
+    !OneApm::Agent::Instrumentation::ActiveRecordSubscriber.subscribed?
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing ActiveRecord 4 instrumentation'
+  end
+
+  executes do
+    subscriber = OneApm::Agent::Instrumentation::ActiveRecordSubscriber.new
+    ActiveSupport::Notifications.subscribe('sql.active_record', subscriber)
+  end
+end

data/lib/one_apm/inst/orm/data_mapper.rb

@@ -0,0 +1,180 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  @name = :data_mapper
+
+  depends_on do
+    defined?(::DataMapper)
+  end
+
+  depends_on do
+    defined?(DataMapper::Model)
+  end
+
+  depends_on do
+    defined?(DataMapper::Resource)
+  end
+
+  depends_on do
+    defined?(DataMapper::Collection)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing DataMapper instrumentation'
+  end
+
+  executes do
+    DataMapper::Model.class_eval do
+      add_method_tracer :get,      'ActiveRecord/#{self.name}/get'
+      add_method_tracer :first,    'ActiveRecord/#{self.name}/first'
+      add_method_tracer :last,     'ActiveRecord/#{self.name}/last'
+      add_method_tracer :all,      'ActiveRecord/#{self.name}/all'
+
+      add_method_tracer :create,   'ActiveRecord/#{self.name}/create'
+      add_method_tracer :create!,  'ActiveRecord/#{self.name}/create'
+      add_method_tracer :update,   'ActiveRecord/#{self.name}/update'
+      add_method_tracer :update!,  'ActiveRecord/#{self.name}/update'
+      add_method_tracer :destroy,  'ActiveRecord/#{self.name}/destroy'
+      add_method_tracer :destroy!, 'ActiveRecord/#{self.name}/destroy'
+
+      # For dm-aggregates and partial dm-ar-finders support:
+      for method in [ :aggregate, :find, :find_by_sql ] do
+        next unless method_defined? method
+        add_method_tracer(method, 'ActiveRecord/#{self.name}/' + method.to_s)
+      end
+
+    end
+  end
+
+  executes do
+    DataMapper::Resource.class_eval do
+      add_method_tracer :update,   'ActiveRecord/#{self.class.name[/[^:]*$/]}/update'
+      add_method_tracer :update!,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/update'
+      add_method_tracer :save,     'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
+      add_method_tracer :save!,    'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
+      add_method_tracer :destroy,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
+      add_method_tracer :destroy!, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
+
+    end
+  end
+
+  executes do
+    DataMapper::Collection.class_eval do
+      # DM's Collection instance methods
+      add_method_tracer :get,       'ActiveRecord/#{self.name}/get'
+      add_method_tracer :first,     'ActiveRecord/#{self.name}/first'
+      add_method_tracer :last,      'ActiveRecord/#{self.name}/last'
+      add_method_tracer :all,       'ActiveRecord/#{self.name}/all'
+
+      add_method_tracer :lazy_load, 'ActiveRecord/#{self.name}/lazy_load'
+
+      add_method_tracer :create,    'ActiveRecord/#{self.name}/create'
+      add_method_tracer :create!,   'ActiveRecord/#{self.name}/create'
+      add_method_tracer :update,    'ActiveRecord/#{self.name}/update'
+      add_method_tracer :update!,   'ActiveRecord/#{self.name}/update'
+      add_method_tracer :destroy,   'ActiveRecord/#{self.name}/destroy'
+      add_method_tracer :destroy!,  'ActiveRecord/#{self.name}/destroy'
+
+      # For dm-aggregates support:
+      for method in [ :aggregate ] do
+        next unless method_defined? method
+        add_method_tracer(method, 'ActiveRecord/#{self.name}/' + method.to_s)
+      end
+
+    end
+  end
+end
+
+LibraryDetection.defer do
+
+  depends_on do
+    defined?(DataMapper) && defined?(DataMapper::Adapters) && defined?(DataMapper::Adapters::DataObjectsAdapter)
+  end
+
+  executes do
+
+    DataMapper::Adapters::DataObjectsAdapter.class_eval do
+
+      add_method_tracer :select,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/select'
+      add_method_tracer :execute, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/execute'
+
+    end
+  end
+end
+
+LibraryDetection.defer do
+
+  depends_on do
+    defined?(DataMapper) && defined?(DataMapper::Validations) && defined?(DataMapper::Validations::ClassMethods)
+  end
+
+  executes do
+    DataMapper::Validations::ClassMethods.class_eval do
+      next unless method_defined? :create
+      add_method_tracer :create,   'ActiveRecord/#{self.name}/create'
+    end
+  end
+end
+
+LibraryDetection.defer do
+
+  depends_on do
+    defined?(DataMapper) && defined?(DataMapper::Transaction)
+  end
+
+  executes do
+    DataMapper::Transaction.module_eval do
+      add_method_tracer :commit, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/commit'
+    end
+  end
+
+end
+
+module OneApm
+  module Agent
+    module Instrumentation
+      module DataMapperInstrumentation
+
+        def log(msg) #THREAD_LOCAL_ACCESS
+          state = OneApm::TransactionState.tl_get
+          return unless state.is_execution_traced?
+          return unless operation = case OneApm::Helper.correctly_encoded(msg.query)
+                                    when /^\s*select/i          then 'find'
+                                    when /^\s*(update|insert)/i then 'save'
+                                    when /^\s*delete/i          then 'destroy'
+                                    else nil
+                                    end
+
+          # FYI: self.to_s will yield connection URI string.
+          duration = msg.duration / 1000000.0
+
+          # Attach SQL to current segment/scope.
+          OneApm::Agent.instance.transaction_sampler.notice_sql(msg.query, nil, duration, state)
+
+          # Record query duration associated with each of the desired metrics.
+          metric = "ActiveRecord/#{operation}"
+          rollup_metrics = ActiveRecordHelper.rollup_metrics_for(metric)
+          metrics = [metric] + rollup_metrics
+          OneApm::Agent.instance.stats_engine.tl_record_unscoped_metrics(metrics, duration)
+        ensure
+          super
+        end
+
+      end
+    end
+  end
+end
+
+LibraryDetection.defer do
+
+  depends_on do
+    defined?(DataObjects) && defined?(DataObjects::Connection)
+  end
+
+  executes do
+    DataObjects::Connection.class_eval do
+      include ::OneApm::Agent::Instrumentation::DataMapperInstrumentation
+    end
+  end
+
+end

data/lib/one_apm/inst/orm/sequel.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  @name = :sequel
+
+  depends_on do
+    defined?(::Sequel)
+  end
+
+  depends_on do
+    !OneApm::Agent.config[:disable_sequel_instrumentation]
+  end
+
+  def supported_sequel_version?
+    Sequel.const_defined?( :MAJOR ) &&
+      ( Sequel::MAJOR > 3 ||
+        Sequel::MAJOR == 3 && Sequel::MINOR >= 37 )
+  end
+
+  executes do
+    if supported_sequel_version?
+
+      ::OneApm::Agent.logger.info 'Installing Sequel instrumentation'
+
+      if Sequel::Database.respond_to?(:extension)
+        Sequel::Database.extension :oneapm_instrumentation
+      else
+        OneApm::Agent.logger.info "Detected Sequel version %s." % [ Sequel::VERSION ]
+        OneApm::Agent.logger.info "Please see additional documentation: " +
+          "https://oneapm.com/docs/ruby/sequel-instrumentation"
+      end
+
+      Sequel.synchronize{Sequel::DATABASES.dup}.each do |db|
+        db.extension :oneapm_instrumentation
+      end
+
+      Sequel::Model.plugin :oneapm_instrumentation
+
+    else
+
+      OneApm::Agent.logger.info "Sequel instrumentation requires at least version 3.37.0."
+
+    end
+
+  end
+
+end

data/lib/one_apm/inst/rack.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'one_apm/inst/transaction_base'
+require 'one_apm/inst/rack/rack'
+require 'one_apm/inst/rack/rack_builder'
+
+LibraryDetection.defer do
+  named :rack
+
+  depends_on do
+    defined?(::Rack) && defined?(::Rack::Builder)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing deferred Rack instrumentation'
+
+    class ::Rack::Builder
+      class << self
+        attr_accessor :_oa_deferred_detection_ran
+      end
+      self._oa_deferred_detection_ran = false
+
+      include ::OneApm::Agent::Instrumentation::RackBuilder
+
+      alias_method :to_app_without_oneapm, :to_app
+      alias_method :to_app, :to_app_with_oneapm_deferred_library_detection
+
+      unless OneApm::Agent.config[:disable_rack_middleware]
+        ::OneApm::Agent.logger.info 'Installing Rack::Builder middleware instrumentation'
+        alias_method :run_without_oneapm, :run
+        alias_method :run, :run_with_oneapm
+
+        alias_method :use_without_oneapm, :use
+        alias_method :use, :use_with_oneapm
+      end
+    end
+  end
+end