newrelic_rpm 3.6.0.74.beta → 3.6.0.78

data/lib/new_relic/agent/instrumentation/rails4/action_view.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+# Listen for ActiveSupport::Notifications events for ActionView render
+# events.  Write metric data and transaction trace segments for each event.
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActionViewSubscriber
+        def initialize
+          @queue_key = ['NewRelic', self.class.name, object_id].join('-')
+        end
+
+        def self.subscribe
+          if !subscribed?
+            ActiveSupport::Notifications.subscribe(/render_.+\.action_view$/,
+                                                   new)
+          end
+        end
+
+        def self.subscribed?
+          # TODO: need to talk to Rails core about an API for this,
+          # rather than digging through Listener ivars
+          ActiveSupport::Notifications.notifier.instance_variable_get(:@subscribers) \
+            .find{|s| s.instance_variable_get(:@delegate).class == self }
+        end
+
+        def start(name, id, payload)
+          event = RenderEvent.new(name, Time.now, nil, id, payload)
+          parent = event_stack[id].last
+          event.parent = parent
+          parent << event if parent
+          event_stack[id].push event
+
+          if NewRelic::Agent.is_execution_traced? && event.recordable?
+            event.scope = NewRelic::Agent.instance.stats_engine \
+              .push_scope(event.metric_name, event.time)
+          end
+        end
+
+        def finish(name, id, payload)
+          event = event_stack[id].pop
+          event.end = Time.now
+
+          if NewRelic::Agent.is_execution_traced? && event.recordable?
+            record_metrics(event)
+            NewRelic::Agent.instance.stats_engine \
+              .pop_scope(event.scope, event.duration, event.end)
+          end
+        end
+
+        def record_metrics(event)
+          NewRelic::Agent.instance.stats_engine \
+            .record_metrics(event.metric_name,
+                            Helper.milliseconds_to_seconds(event.duration),
+                            :scoped => true)
+        end
+
+        def event_stack
+          Thread.current[@queue_key] ||= Hash.new {|h,id| h[id] = [] }
+        end
+
+        if defined?(ActiveSupport::Notifications::Event)
+          class RenderEvent < ActiveSupport::Notifications::Event
+            attr_accessor :parent, :scope
+
+            # Nearly every "render_blah.action_view" event has a child
+            # in the form of "!render_blah.action_view".  The children
+            # are the ones we want to record.  There are a couple
+            # special cases of events without children.
+            def recordable?
+              name[0] == '!' ||
+                metric_name == 'View/text template/Rendering' ||
+                metric_name == 'View/(unknown)/Partial'
+            end
+
+            def metric_name
+              if parent && (payload[:virtual_path] ||
+                  (parent.payload[:identifier] =~ /template$/))
+                return parent.metric_name
+              elsif payload[:virtual_path]
+                identifier = payload[:virtual_path]
+              else
+                identifier = payload[:identifier]
+              end
+
+              # memoize
+              @metric_name ||= "View/#{metric_path(identifier)}/#{metric_action(name)}"
+              @metric_name
+            end
+
+            def metric_path(identifier)
+              if identifier == nil
+                'file'
+              elsif identifier =~ /template$/
+                identifier
+              elsif (parts = identifier.split('/')).size > 1
+                parts[-2..-1].join('/')
+              else
+                '(unknown)'
+              end
+            end
+
+            def metric_action(name)
+              case name
+              when /render_template.action_view$/  then 'Rendering'
+              when 'render_partial.action_view'    then 'Partial'
+              when 'render_collection.action_view' then 'Partial'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :rails4_view
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
+  end
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_view_instrumentation] &&
+      !NewRelic::Agent::Instrumentation::ActionViewSubscriber.subscribed?
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Rails 4 view instrumentation'
+  end
+
+  executes do
+    NewRelic::Agent::Instrumentation::ActionViewSubscriber.subscribe
+  end
+end

data/lib/new_relic/agent/instrumentation/rails4/active_record.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+require 'new_relic/agent/instrumentation/active_record_helper'
+
+# Listen for ActiveSupport::Notifications events for ActiveRecord query
+# events.  Write metric data, transaction trace segments and slow sql
+# nodes for each event.
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActiveRecordSubscriber
+        include NewRelic::Agent::Instrumentation
+
+        def self.subscribed?
+          # TODO: need to talk to Rails core about an API for this,
+          # rather than digging through Listener ivars
+          ActiveSupport::Notifications.notifier.listeners_for('sql.active_record') \
+            .find{|l| l.instance_variable_get(:@delegate).class == self }
+        end
+
+        def call(*args)
+          return unless NewRelic::Agent.is_execution_traced?
+
+          event = ActiveSupport::Notifications::Event.new(*args)
+          record_metrics(event)
+          notice_sql(event)
+        end
+
+        def notice_sql(event)
+          config = active_record_config_for_event(event)
+          metric = base_metric(event)
+
+          # enter transaction trace segment
+          scope = NewRelic::Agent.instance.stats_engine.push_scope(metric, event.time)
+
+          NewRelic::Agent.instance.transaction_sampler \
+            .notice_sql(event.payload[:sql], config,
+                        Helper.milliseconds_to_seconds(event.duration))
+
+          NewRelic::Agent.instance.sql_sampler \
+            .notice_sql(event.payload[:sql], metric, config,
+                        Helper.milliseconds_to_seconds(event.duration))
+
+          # exit transaction trace segment
+          NewRelic::Agent.instance.stats_engine.pop_scope(scope, event.duration, event.end)
+        end
+
+        def record_metrics(event)
+          base = base_metric(event)
+          NewRelic::Agent.instance.stats_engine.record_metrics(base,
+                              Helper.milliseconds_to_seconds(event.duration),
+                              :scoped => true)
+
+          other_metrics = ActiveRecordHelper.rollup_metrics_for(base)
+          if config = active_record_config_for_event(event)
+            other_metrics << ActiveRecordHelper.remote_service_metric(config[:adapter], config[:host])
+          end
+
+          other_metrics.compact.each do |metric_name|
+            NewRelic::Agent.instance.stats_engine.record_metrics(metric_name,
+                                            Helper.milliseconds_to_seconds(event.duration),
+                                            :scoped => false)
+          end
+        end
+
+        def base_metric(event)
+          ActiveRecordHelper.metric_for_name(event.payload[:name]) ||
+            ActiveRecordHelper.metric_for_sql(NewRelic::Helper.correctly_encoded(event.payload[:sql]))
+        end
+
+        def active_record_config_for_event(event)
+          return unless event.payload[:connection_id]
+
+          # TODO: This will not work for JRuby and in any case we want
+          # this to be part of the event meta data so it doesn't have
+          # to be dug out of an ivar.
+          connection = ObjectSpace._id2ref(event.payload[:connection_id])
+          connection.instance_variable_get(:@config) if connection
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :active_record
+
+  depends_on do
+    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
+      defined?(::ActiveRecord::VERSION) &&
+      ::ActiveRecord::VERSION::MAJOR.to_i >= 4
+  end
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_activerecord_instrumentation] &&
+      !NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.subscribed?
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing ActiveRecord instrumentation'
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe('sql.active_record',
+      NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.new)
+  end
+end

data/lib/new_relic/agent/null_logger.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+# A stub object that we can use in place of a real Logger instance when
+# the agent is disabled.
+module NewRelic
+  module Agent
+    class NullLogger
+      def method_missing(method, *args, &blk)
+        nil
+      end
+    end
+  end
+end

data/lib/new_relic/agent/stats.rb

@@ -101,6 +101,7 @@ module NewRelic
       end
 
       def ==(other)
+        other.class == self.class &&
         (
           @min_call_time        == other.min_call_time &&
           @max_call_time        == other.max_call_time &&

data/lib/new_relic/agent/stats_engine/transactions.rb

@@ -75,17 +75,17 @@ module Agent
         @transaction_sampler.notice_pop_scope(scope.name, time) if sampler_enabled?
         scope
       end
-      
+
       def sampler_enabled?
         @transaction_sampler && Agent.config[:'transaction_tracer.enabled']
       end
-      
+
       # Rename the segment associated with the last pushed scope to +new_name+.
       def rename_scope_segment( new_name )
         self.peek_scope.name = new_name
-        @transaction_sampler.rename_scope_segment( new_name )
+        @transaction_sampler.rename_scope_segment( new_name ) if sampler_enabled?
       end
-      
+
       # Returns the latest ScopeStackElement
       def peek_scope
         scope_stack.last

data/lib/new_relic/control/frameworks/rails.rb

@@ -125,43 +125,6 @@ module NewRelic
           File.join(root,'vendor','rails')
         end
 
-        def rails_gem_list
-          ::Rails.configuration.gems.map do |gem|
-            version = (gem.respond_to?(:version) && gem.version) ||
-              (gem.specification.respond_to?(:version) && gem.specification.version)
-            gem.name + (version ? "(#{version})" : "")
-          end
-        end
-
-        # Collect the Rails::Info into an associative array as well as the list of plugins
-        def append_environment_info
-          local_env.append_environment_value('Rails version'){ ::Rails::VERSION::STRING }
-          if rails_version >= NewRelic::VersionNumber.new('2.2.0')
-            local_env.append_environment_value('Rails threadsafe') do
-              ::Rails.configuration.action_controller.allow_concurrency == true
-            end
-          end
-          local_env.append_environment_value('Rails Env') { ENV['RAILS_ENV'] }
-          if rails_version >= NewRelic::VersionNumber.new('2.1.0')
-            local_env.append_gem_list do
-              (bundler_gem_list + rails_gem_list).uniq
-            end
-            # The plugins is configured manually.  If it's nil, it loads everything non-deterministically
-            if ::Rails.configuration.plugins
-              local_env.append_plugin_list { ::Rails.configuration.plugins }
-            else
-              ::Rails.configuration.plugin_paths.each do |path|
-                local_env.append_plugin_list { Dir[File.join(path, '*')].collect{ |p| File.basename p if File.directory? p }.compact }
-              end
-            end
-          else
-            # Rails prior to 2.1, can't get the gems.  Find plugins in the default location
-            local_env.append_plugin_list do
-              Dir[File.join(root, 'vendor', 'plugins', '*')].collect{ |p| File.basename p if File.directory? p }.compact
-            end
-          end
-        end
-
         def install_shim
           super
           require 'new_relic/agent/instrumentation/controller_instrumentation'

data/lib/new_relic/control/frameworks/rails3.rb

@@ -46,23 +46,6 @@ module NewRelic
 
         protected
 
-        # Collect the Rails::Info into an associative array as well as the list of plugins
-        def append_environment_info
-          local_env.append_environment_value('Rails version'){ ::Rails::VERSION::STRING }
-          local_env.append_environment_value('Rails threadsafe') do
-            true == ::Rails.configuration.action_controller.allow_concurrency
-          end
-          local_env.append_environment_value('Rails Env') { env }
-          local_env.append_gem_list do
-            bundler_gem_list
-          end
-          append_plugin_list
-        end
-
-        def append_plugin_list
-          local_env.append_plugin_list { ::Rails.configuration.plugins.to_a }
-        end
-        
         def install_shim
           super
           ActiveSupport.on_load(:action_controller) do

data/lib/new_relic/control/instance_methods.rb

@@ -3,6 +3,7 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require 'new_relic/language_support'
+require 'new_relic/agent/null_logger'
 require 'new_relic/agent/agent_logger'
 
 module NewRelic
@@ -74,8 +75,6 @@ module NewRelic
           start_agent
           install_instrumentation
           load_samplers unless Agent.config[:disable_samplers]
-          local_env.gather_environment_info
-          append_environment_info
         elsif !Agent.config[:agent_enabled]
           install_shim
         end

data/lib/new_relic/environment_report.rb

@@ -0,0 +1,159 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module NewRelic
+  # The EnvironmentReport is responsible for analyzing the application's
+  # environment and generating the data for the Environment Report in New
+  # Relic's interface.
+  #
+  # It contains useful system information like Ruby version, OS, loaded gems,
+  # etc.
+  #
+  # Additional logic can be registered by using the EnvironmentReport.report_on
+  # hook.
+  class EnvironmentReport
+
+    # This is the main interface for registering logic that should be included
+    # in the Environment Report. For example:
+    #
+    # EnvironmentReport.report_on "Day of week" do
+    #   Time.now.strftime("%A")
+    # end
+    #
+    # The passed blocks will be run in EnvironmentReport instances on #initialize.
+    #
+    # Errors raised in passed blocks will be handled and logged at debug, so it
+    # is safe to report on things that may not work in certain environments.
+    #
+    # The blocks should only return strings or arrays full of strings.  Falsey
+    # values will be ignored.
+    def self.report_on(key, &block)
+      registered_reporters[key] = block
+    end
+
+    def self.registered_reporters
+      @registered_reporters ||= Hash.new
+    end
+
+    # allow the logic to be swapped out in tests
+    def self.registered_reporters=(logic)
+      @registered_reporters = logic
+    end
+
+    # register reporting logic
+    ####################################
+    report_on 'Gems' do
+      begin
+        Bundler.rubygems.all_specs.map { |gem| "#{gem.name}(#{gem.version})" }
+      rescue
+        # There are certain rubygem, bundler, rails combinations (e.g. gem
+        # 1.6.2, rails 2.3, bundler 1.2.3) where the code above throws an error
+        # in bundler because of rails monkey patching gem.  The below does work
+        # though so try it if the above fails.
+        Bundler.load.specs.map do | spec |
+          version = (spec.respond_to?(:version) && spec.version)
+          spec.name + (version ? "(#{version})" : "")
+        end
+      end
+    end
+    report_on('Plugin List'){ ::Rails.configuration.plugins.to_a }
+    report_on('Ruby version'){ RUBY_VERSION }
+    report_on('Ruby description'){ RUBY_DESCRIPTION }
+    report_on('Ruby platform'){ RUBY_PLATFORM }
+    report_on('Ruby patchlevel'){ RUBY_PATCHLEVEL.to_s }
+    report_on('JRuby version') { JRUBY_VERSION }
+    report_on('Java VM version') { ENV_JAVA['java.vm.version']}
+    report_on 'Processors' do
+      cpuinfo = ''
+      proc_file = '/proc/cpuinfo'
+      File.open(proc_file) do |f|
+        loop do
+          begin
+            cpuinfo << f.read_nonblock(4096).strip
+          rescue EOFError
+            break
+          rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+            cpuinfo = ''
+            break # don't select file handle, just give up
+          end
+        end
+      end
+      processors = cpuinfo.split("\n").select {|line| line =~ /^processor\s*:/ }.size
+
+      if processors == 0
+        processors = nil # assume there is at least one processor
+        ::NewRelic::Agent.logger.warn("Cannot determine the number of processors in #{proc_file}")
+      end
+      processors
+    end
+    report_on 'Arch' do
+      arch = `uname -p`
+      arch = ENV['PROCESSOR_ARCHITECTURE'] if arch == ''
+      arch
+    end
+    report_on('OS version'){ `uname -v` }
+    report_on('OS') do
+      os = `uname -s`
+      os = ENV['OS'] if os == ''
+      os
+    end
+    report_on 'Database adapter' do
+      ActiveRecord::Base.configurations[NewRelic::Control.instance.env]['adapter']
+    end
+    report_on('Framework') { Agent.config[:framework].to_s }
+    report_on('Dispatcher') { Agent.config[:dispatcher].to_s }
+    report_on('Environment') { NewRelic::Control.instance.env }
+    report_on('Rails version') { ::Rails::VERSION::STRING }
+    report_on 'Rails threadsafe' do
+      ::Rails.configuration.action_controller.allow_concurrency
+    end
+    report_on 'Rails Env' do
+      if defined? ::Rails and ::Rails.respond_to?(:env)
+        ::Rails.env
+      else
+        ENV['RAILS_ENV']
+      end
+    end
+    # end reporting logic
+    ####################################
+
+
+    attr_reader :data
+    # Generate the report based on the class level logic.
+    def initialize
+      @data = self.class.registered_reporters.inject(Hash.new) do |data, (key, logic)|
+        begin
+          value = logic.call
+          if value
+            data[key] = value
+
+            Agent.record_metric("Supportability/EnvironmentReport/success", 0.0)
+            Agent.record_metric("Supportability/EnvironmentReport/success/#{key}", 0.0)
+          else
+            Agent.logger.debug("EnvironmentReport ignoring value for #{key.inspect} which came back falsey: #{value.inspect}")
+            Agent.record_metric("Supportability/EnvironmentReport/empty", 0.0)
+            Agent.record_metric("Supportability/EnvironmentReport/empty/#{key}", 0.0)
+          end
+        rescue => e
+          Agent.logger.debug("EnvironmentReport failed to retrieve value for #{key.inspect}: #{e}")
+          Agent.record_metric("Supportability/EnvironmentReport/error", 0.0)
+          Agent.record_metric("Supportability/EnvironmentReport/error/#{key}", 0.0)
+        end
+        data
+      end
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def []=(key, value)
+      @data[key] = value
+    end
+
+    def to_a
+      @data.to_a
+    end
+  end
+end