mmtrix_rpm 1.0.0.1

data/lib/mmtrix/agent/instrumentation/active_record_helper.rb

@@ -0,0 +1,189 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'mmtrix/agent/datastores/metric_helper'
+require 'mmtrix/agent/deprecator'
+
+module Mmtrix
+  module Agent
+    module Instrumentation
+      module ActiveRecordHelper
+        module_function
+
+        # Used by both the AR 3.x and 4.x instrumentation
+        def instrument_writer_methods
+          ::ActiveRecord::Base.class_eval do
+            alias_method :save_without_mmtrix, :save
+
+            def save(*args, &blk)
+              ::Mmtrix::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                save_without_mmtrix(*args, &blk)
+              end
+            end
+
+            alias_method :save_without_mmtrix!, :save!
+
+            def save!(*args, &blk)
+              ::Mmtrix::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                save_without_mmtrix!(*args, &blk)
+              end
+            end
+          end
+
+          ::ActiveRecord::Relation.class_eval do
+            alias_method :update_all_without_mmtrix, :update_all
+
+            def update_all(*args, &blk)
+              ::Mmtrix::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                update_all_without_mmtrix(*args, &blk)
+              end
+            end
+
+            alias_method :delete_all_without_mmtrix, :delete_all
+
+            def delete_all(*args, &blk)
+              ::Mmtrix::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                delete_all_without_mmtrix(*args, &blk)
+              end
+            end
+
+            alias_method :destroy_all_without_mmtrix, :destroy_all
+
+            def destroy_all(*args, &blk)
+              ::Mmtrix::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                destroy_all_without_mmtrix(*args, &blk)
+              end
+            end
+          end
+        end
+
+        ACTIVE_RECORD = "ActiveRecord".freeze unless defined?(ACTIVE_RECORD)
+        OTHER         = "other".freeze unless defined?(OTHER)
+
+        def metrics_for(name, sql, adapter_name)
+          product   = map_product(adapter_name)
+          splits    = split_name(name)
+          model     = model_from_splits(splits)
+          operation = operation_from_splits(splits, sql)
+
+          Mmtrix::Agent::Datastores::MetricHelper.metrics_for(product,
+                                                                operation,
+                                                                model,
+                                                                ACTIVE_RECORD)
+        end
+
+        # @deprecated
+        def rollup_metrics_for(*_)
+          Mmtrix::Agent::Deprecator.deprecate("ActiveRecordHelper.rollup_metrics_for",
+                                                "Mmtrix::Agent::Datastores::MetricHelper.metrics_for")
+
+          rollup_metric = if Mmtrix::Agent::Transaction.recording_web_transaction?
+            Mmtrix::Agent::Datastores::MetricHelper::WEB_ROLLUP_METRIC
+          else
+            Mmtrix::Agent::Datastores::MetricHelper::OTHER_ROLLUP_METRIC
+          end
+
+          [rollup_metric,
+           Mmtrix::Agent::Datastores::MetricHelper::ROLLUP_METRIC]
+        end
+
+        SPACE = ' '.freeze unless defined?(SPACE)
+        EMPTY = [].freeze unless defined?(EMPTY)
+
+        def split_name(name)
+          if name && name.respond_to?(:split)
+            name.split(SPACE)
+          else
+            EMPTY
+          end
+        end
+
+        def model_from_splits(splits)
+          if splits.length == 2
+            splits.first
+          else
+            nil
+          end
+        end
+
+        def operation_from_splits(splits, sql)
+          if splits.length == 2
+            map_operation(splits[1])
+          else
+            Mmtrix::Agent::Database.parse_operation_from_query(sql) || OTHER
+          end
+        end
+
+        # These are used primarily to optimize and avoid allocation on well
+        # known operations coming in. Anything not matching the list is fine,
+        # it just needs to get downcased directly for use.
+        OPERATION_NAMES = {
+          'Find'    => 'find',
+          'Load'    => 'find',
+          'Count'   => 'find',
+          'Exists'  => 'find',
+          'Create'  => 'create',
+          'Columns' => 'columns',
+          'Indexes' => 'indexes',
+          'Destroy' => 'destroy',
+          'Update'  => 'update',
+          'Save'    => 'save'
+        }.freeze unless defined?(OPERATION_NAMES)
+
+        def map_operation(raw_operation)
+          direct_op = OPERATION_NAMES[raw_operation]
+          return direct_op if direct_op
+
+          raw_operation.downcase
+        end
+
+        PRODUCT_NAMES = {
+          "mysql"      => "MySQL",
+          "mysql2"     => "MySQL",
+
+          "postgresql" => "Postgres",
+
+          "sqlite3"    => "SQLite",
+
+          # https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
+          "jdbcmysql"  => "MySQL",
+
+          # https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
+          "jdbcpostgresql" => "Postgres",
+
+          # https://rubygems.org/gems/activerecord-jdbcsqlite3-adapter
+          "jdbcsqlite3"    => "SQLite",
+
+          # https://rubygems.org/gems/activerecord-jdbcderby-adapter
+          "derby"      => "Derby",
+          "jdbcderby"  => "Derby",
+
+          # https://rubygems.org/gems/activerecord-jdbc-adapter
+          "jdbc"       => "JDBC",
+
+          # https://rubygems.org/gems/activerecord-jdbcmssql-adapter
+          "jdbcmssql"  => "MSSQL",
+          "mssql"      => "MSSQL",
+
+          # https://rubygems.org/gems/activerecord-sqlserver-adapter
+          "sqlserver"  => "MSSQL",
+
+          # https://rubygems.org/gems/activerecord-odbc-adapter
+          "odbc"       => "ODBC",
+
+          # https://rubygems.org/gems/activerecord-oracle_enhanced-adapter
+          "oracle_enhanced" => "Oracle"
+        }.freeze unless defined?(PRODUCT_NAMES)
+
+        ACTIVE_RECORD_DEFAULT_PRODUCT_NAME = "ActiveRecord".freeze unless defined?(ACTIVE_RECORD_DEFAULT_PRODUCT_NAME)
+
+        def map_product(adapter_name)
+          PRODUCT_NAMES.fetch(adapter_name,
+                              ACTIVE_RECORD_DEFAULT_PRODUCT_NAME)
+        end
+
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/instrumentation/active_record_subscriber.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+require 'mmtrix/agent/instrumentation/active_record_helper'
+require 'mmtrix/agent/instrumentation/evented_subscriber'
+
+# Listen for ActiveSupport::Notifications events for ActiveRecord query
+# events.  Write metric data, transaction trace nodes and slow sql
+# nodes for each event.
+module Mmtrix
+  module Agent
+    module Instrumentation
+      class ActiveRecordSubscriber < EventedSubscriber
+        CACHED_QUERY_NAME = 'CACHE'.freeze unless defined? CACHED_QUERY_NAME
+
+        def initialize
+          # We cache this in an instance variable to avoid re-calling method
+          # on each query.
+          @explainer = method(:get_explain_plan)
+          super
+        end
+
+        def start(name, id, payload) #THREAD_LOCAL_ACCESS
+          return if payload[:name] == CACHED_QUERY_NAME
+          return unless Mmtrix::Agent.tl_is_execution_traced?
+          super
+        rescue => e
+          log_notification_error(e, name, 'start')
+        end
+
+        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
+          return if payload[:name] == CACHED_QUERY_NAME
+          state = Mmtrix::Agent::TransactionState.tl_get
+          return unless state.is_execution_traced?
+          event  = pop_event(id)
+          config = active_record_config_for_event(event)
+          base_metric = record_metrics(event, config)
+          notice_sql(state, event, config, base_metric)
+        rescue => e
+          log_notification_error(e, name, 'finish')
+        end
+
+        def get_explain_plan( config, query )
+          connection = Mmtrix::Agent::Database.get_connection(config) do
+            ::ActiveRecord::Base.send("#{config[:adapter]}_connection",
+                                      config)
+          end
+          if connection && connection.respond_to?(:execute)
+            return connection.execute("EXPLAIN #{query}")
+          end
+        end
+
+        def notice_sql(state, event, config, metric)
+          stack  = state.traced_method_stack
+
+          # enter transaction trace node
+          frame = stack.push_frame(state, :active_record, event.time)
+
+          Mmtrix::Agent.instance.transaction_sampler \
+            .notice_sql(event.payload[:sql], config,
+                        Helper.milliseconds_to_seconds(event.duration),
+                        state, @explainer)
+
+          Mmtrix::Agent.instance.sql_sampler \
+            .notice_sql(event.payload[:sql], metric, config,
+                        Helper.milliseconds_to_seconds(event.duration),
+                        state, @explainer)
+
+          # exit transaction trace node
+          stack.pop_frame(state, frame, metric, event.end)
+        end
+
+        def record_metrics(event, config) #THREAD_LOCAL_ACCESS
+          base, *other_metrics = ActiveRecordHelper.metrics_for(event.payload[:name],
+                                                               Mmtrix::Helper.correctly_encoded(event.payload[:sql]),
+                                                               config && config[:adapter])
+
+          Mmtrix::Agent.instance.stats_engine.tl_record_scoped_and_unscoped_metrics(
+            base, other_metrics,
+            Helper.milliseconds_to_seconds(event.duration))
+
+          base
+        end
+
+        def active_record_config_for_event(event)
+          return unless event.payload[:connection_id]
+
+          connection = nil
+          connection_id = event.payload[:connection_id]
+
+          ::ActiveRecord::Base.connection_handler.connection_pool_list.each do |handler|
+            connection = handler.connections.detect do |conn|
+              conn.object_id == connection_id
+            end
+
+            break if connection
+          end
+
+          connection.instance_variable_get(:@config) if connection
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/instrumentation/acts_as_solr.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+module Mmtrix
+  module Instrumentation
+    module ActsAsSolrInstrumentation
+      module ParserMethodsInstrumentation
+        def parse_query_with_mmtrix(*args)
+          self.class.trace_execution_scoped(["SolrClient/ActsAsSolr/query"]) do
+            t0 = Time.now
+            begin
+              parse_query_without_mmtrix(*args)
+            ensure
+              Mmtrix::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect, (Time.now - t0).to_f) rescue nil
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.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
+    ::Mmtrix::Agent.logger.info 'Installing ActsAsSolr instrumentation'
+  end
+
+  executes do
+    ActsAsSolr::ParserMethods.module_eval do
+      include Mmtrix::Instrumentation::ActsAsSolrInstrumentation::ParserMethodsInstrumentation
+      alias :parse_query_without_mmtrix :parse_query
+      alias :parse_query :parse_query_with_mmtrix
+    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/mmtrix/agent/instrumentation/authlogic.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+DependencyDetection.defer do
+  @name = :authlogic
+
+  depends_on do
+    defined?(Authlogic) &&
+      defined?(Authlogic::Session) &&
+      defined?(Authlogic::Session::Base)
+  end
+
+  executes do
+    ::Mmtrix::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