newrelic_rpm 3.6.0.83 → 3.6.1.85.beta

data/CHANGELOG

@@ -1,6 +1,33 @@
 
 # New Relic Ruby Agent Release Notes #
 
+## v3.6.1 ##
+
+  * Full URIs for HTTP requests are recorded in transaction traces
+
+  When recording a transaction trace node for an outgoing HTTP call via
+  Net::HTTP, the agent will now save the full URI (instead of just the hostname)
+  for the request. Embedded credentials, the query string, and the fragment will
+  be stripped from the URI before it is saved.
+
+  * Simplify Agent Autostart Logic
+
+  Previously the agent would only start when it detected a supported
+  "Dispatcher", meaning a known web server or background task framework.  This
+  was problematic for customers using webservers that the agent was not
+  configured to detect (e.g. Puma).  Now the agent will attempt to report any
+  time it detects it is running in a monitored environment (e.g. production).
+  There are two exceptions to this.  The agent will not autostart in a rails
+  console or irb session or when the process was invoked by a rake task (e.g.
+  rake assets:precompile).  The NEWRELIC_ENABLE environment variable can be set
+  to true or false to force the agent to start or not start.
+
+  * Don't attempt to resolve collector hostname when proxy is in use
+
+  When a proxy is configured, the agent will not attempt to lookup and cache the
+  IP address of New Relic server to which it is sending data, since DNS may not
+  be available in some environments. Thanks to Bill Kirtley for the contribution
+
 ## v3.6.0 ##
 
   * Sidekiq supprt

data/Gemfile

@@ -5,15 +5,10 @@ group :development do
   # There's problems with the test task in rake 10
   # https://github.com/jimweirich/rake/issues/144
   gem 'rake', '0.9.6'
-  if RUBY_VERSION > '1.9.0'
-    gem 'mocha', '~>0.13.0', :require => false
-  else
-    gem 'mocha', '~>0.12.0'
-  end
-  gem 'shoulda', '~>3.0.1'
+  gem 'mocha', '~>0.13.0', :require => false
   gem 'sdoc-helpers'
   gem 'rdoc', '>= 2.4.2'
-  gem 'rails', '~>3.2.0'
+  gem 'rails', '~>3.2.13'
   gem 'sqlite3', :platform => 'mri'
   gem 'activerecord-jdbcsqlite3-adapter', :platform => 'jruby'
   gem 'jruby-openssl', :platform => 'jruby'

data/README.md

@@ -23,7 +23,7 @@ automatically in Rails applications.
 
 ## Supported Environments
 
-* Ruby 1.8.6, 1.8.7, REE, 1.9.x
+* Ruby 1.8.6, 1.8.7, REE, 1.9.x, 2.0.x
 * JRuby 1.6 and 1.7
 * Rails 2.0 or later for Production Mode
 * Rails 2.3 or later for Developer Mode

data/lib/new_relic/agent/agent.rb

@@ -8,6 +8,7 @@ require 'net/http'
 require 'logger'
 require 'zlib'
 require 'stringio'
+require 'new_relic/agent/autostart'
 require 'new_relic/agent/new_relic_service'
 require 'new_relic/agent/pipe_service'
 require 'new_relic/agent/configuration/manager'
@@ -141,7 +142,7 @@ module NewRelic
           metric_info = NewRelic::MetricParser::MetricParser.for_metric_named(metric)
 
           if metric_info.is_web_transaction?
-            NewRelic::Agent::Instrumentation::MetricFrame.record_apdex(metric_info, duration_seconds, duration_seconds, is_error)
+            NewRelic::Agent::Transaction.record_apdex(metric_info, duration_seconds, duration_seconds, is_error)
           end
           metrics = metric_info.summary_metrics
 
@@ -337,7 +338,7 @@ module NewRelic
           # assist with proper dispatcher detection
           def log_dispatcher
             dispatcher_name = Agent.config[:dispatcher].to_s
-            return if log_if(dispatcher_name.empty?, :warn, "No dispatcher detected.")
+            return if log_if(dispatcher_name.empty?, :info, "No known dispatcher detected.")
             ::NewRelic::Agent.logger.info "Dispatcher: #{dispatcher_name}"
           end
 

data/lib/new_relic/agent/autostart.rb

@@ -0,0 +1,56 @@
+# 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
+  module Agent
+    # A singleton responsible for determining if the agent should start
+    # monitoring.
+    #
+    # If the agent is in a monitored environment (e.g. production) it will
+    # attempt to avoid starting at "inapproriate" times, for example in an IRB
+    # session.  On Heroku, logs typically go to STDOUT so agent logs can spam
+    # the console during interactive sessions.
+    #
+    # It should be possible to override Autostart logic with an explicit
+    # configuration, for example the NEWRELIC_ENABLE environment variable or
+    # agent_enabled key in newrelic.yml
+    module Autostart
+      extend self
+
+
+      # The constants and execuatables (i.e. $0) used can be configured with
+      # via the config keys 'autostart.blacklisted_constants' and
+      # 'autostart.blacklisted_executables'
+      def agent_should_start?
+          !::NewRelic::Agent.config['autostart.blacklisted_constants'] \
+            .split(/\s*,\s*/).any?{ |name| constant_is_defined?(name) } &&
+          !::NewRelic::Agent.config['autostart.blacklisted_executables'] \
+            .split(/\s*,\s*/).any?{ |bin| File.basename($0) == bin } &&
+          !in_blacklisted_rake_task?
+      end
+
+      # Lookup whether namespaced constants (e.g. ::Foo::Bar::Baz) are in the
+      # environment.
+      def constant_is_defined?(const_name)
+        const_name.to_s.sub(/\A::/,'').split('::').inject(Object) do |namespace, name|
+          begin
+            namespace.const_get(name)
+          rescue NameError
+            false
+          end
+        end
+      end
+
+      def in_blacklisted_rake_task?
+        tasks = begin
+            Rake.application.top_level_tasks
+          rescue => e
+            ::NewRelic::Agent.logger.debug("Not in Rake environment so skipping blacklisted_rake_tasks check: #{e}")
+            []
+          end
+        !(tasks & ::NewRelic::Agent.config['autostart.blacklisted_rake_tasks'].split(/\s*,\s*/)).empty?
+      end
+    end
+  end
+end

data/lib/new_relic/agent/browser_monitoring.rb

@@ -9,7 +9,7 @@ module NewRelic
     # This module contains support for Real User Monitoring - the
     # javascript generation and configuration
     module BrowserMonitoring
-      class DummyMetricFrame
+      class DummyTransaction
         def initialize
           @attributes = {}
         end
@@ -21,9 +21,13 @@ module NewRelic
         def queue_time
           0.0
         end
+
+        def name
+          '(unknown)'
+        end
       end
 
-      @@dummy_metric_frame = DummyMetricFrame.new
+      @@dummy_txn = DummyTransaction.new
 
       # This method returns a string suitable for inclusion in a page
       # - known as 'manual instrumentation' for Real User
@@ -52,6 +56,7 @@ module NewRelic
       # page as is reasonably possible.
       def browser_timing_footer
         if insert_js?
+          NewRelic::Agent::Transaction.freeze_name
           generate_footer_js(NewRelic::Agent.instance.beacon_configuration)
         else
           ""
@@ -73,19 +78,19 @@ module NewRelic
       end
 
       def browser_monitoring_transaction_name
-        NewRelic::Agent::TransactionInfo.get.transaction_name
+        current_transaction.name || '(unknown)'
       end
 
       def browser_monitoring_queue_time
-        clamp_to_positive((current_metric_frame.queue_time.to_f * 1000.0).round)
+        clamp_to_positive((current_transaction.queue_time.to_f * 1000.0).round)
       end
 
       def browser_monitoring_app_time
         clamp_to_positive(((Time.now - browser_monitoring_start_time).to_f * 1000.0).round)
       end
 
-      def current_metric_frame
-        Thread.current[:last_metric_frame] || @@dummy_metric_frame
+      def current_transaction
+        NewRelic::Agent::TransactionInfo.get.transaction || @@dummy_txn
       end
 
       def clamp_to_positive(value)
@@ -99,7 +104,7 @@ module NewRelic
 
       def self.timings
         NewRelic::Agent::Instrumentation::BrowserMonitoringTimings.new(
-          current_metric_frame.queue_time,
+          current_transaction.queue_time,
           NewRelic::Agent::TransactionInfo.get)
       end
 
@@ -163,13 +168,13 @@ module NewRelic
         end
       end
 
-      def metric_frame_attribute(key)
-        current_metric_frame.user_attributes[key] || ""
+      def transaction_attribute(key)
+        current_transaction.user_attributes[key] || ""
       end
 
       def tt_guid
-        txn = NewRelic::Agent::TransactionInfo.get
-        return txn.guid if txn.include_guid?
+        transaction = NewRelic::Agent::TransactionInfo.get
+        return transaction.guid if transaction.include_guid?
         ""
       end
 
@@ -180,9 +185,9 @@ module NewRelic
       def footer_js_string(config)
         obfuscated_transaction_name = obfuscate(config, browser_monitoring_transaction_name)
 
-        user = obfuscate(config, metric_frame_attribute(:user))
-        account = obfuscate(config, metric_frame_attribute(:account))
-        product = obfuscate(config, metric_frame_attribute(:product))
+        user = obfuscate(config, transaction_attribute(:user))
+        account = obfuscate(config, transaction_attribute(:account))
+        product = obfuscate(config, transaction_attribute(:product))
 
         html_safe_if_needed(%'<script type="text/javascript">#{config.browser_timing_static_footer}NREUMQ.push(["#{config.finish_command}","#{Agent.config[:beacon]}","#{Agent.config[:browser_key]}","#{Agent.config[:application_id]}","#{obfuscated_transaction_name}",#{browser_monitoring_queue_time},#{browser_monitoring_app_time},new Date().getTime(),"#{tt_guid}","#{tt_token}","#{user}","#{account}","#{product}"]);</script>')
       end

data/lib/new_relic/agent/configuration/defaults.rb

@@ -48,11 +48,21 @@ module NewRelic
         end,
         :enabled         => true,
         :monitor_mode    => Proc.new { self[:enabled] },
+
+        # agent_enabled determines whether the agent should try to start and
+        # report data.
         :agent_enabled   => Proc.new do
           self[:enabled] &&
           (self[:developer_mode] || self[:monitor_mode] || self[:monitor_daemons]) &&
-          !!NewRelic::Agent.config[:dispatcher]
+          ::NewRelic::Agent::Autostart.agent_should_start?
         end,
+        # Don't autostart the agent if we're in IRB or Rails console.
+        # This config option accepts a comma seperated list of constants.
+        :'autostart.blacklisted_constants' => 'Rails::Console',
+        # Comma seperated list of executables that you don't want to trigger
+        # agents start. e.g. 'rake,my_ruby_script.rb'
+        :'autostart.blacklisted_executables' => 'irb',
+        :'autostart.blacklisted_rake_tasks' => 'about,assets:clean,assets:clobber,assets:environment,assets:precompile,db:create,db:drop,db:fixtures:load,db:migrate,db:migrate:status,db:rollback,db:schema:cache:clear,db:schema:cache:dump,db:schema:dump,db:schema:load,db:seed,db:setup,db:structure:dump,db:version,doc:app,log:clear,middleware,notes,notes:custom,rails:template,rails:update,routes,secret,spec,spec:controllers,spec:helpers,spec:models,spec:rcov,stats,test,test:all,test:all:db,test:recent,test:single,test:uncommitted,time:zones:all,tmp:clear,tmp:create',
         :developer_mode  => Proc.new { self[:developer] },
         :developer       => false,
         :apdex_t         => 0.5,
@@ -117,7 +127,7 @@ module NewRelic
 
         :'error_collector.enabled'        => true,
         :'error_collector.capture_source' => true,
-        :'error_collector.ignore_errors'  => 'ActionController::RoutingError',
+        :'error_collector.ignore_errors'  => 'ActionController::RoutingError,Sinatra::NotFound',
 
         :'rum.enabled'            => true,
         :'rum.jsonp'              => true,

data/lib/new_relic/agent/configuration/environment_source.rb

@@ -29,7 +29,10 @@ module NewRelic
           end
 
           boolean_map = {
-            'NEWRELIC_ENABLE' => :agent_enabled
+            'NEWRELIC_ENABLE' => :agent_enabled,
+            'NEWRELIC_ENABLED' => :agent_enabled,
+            'NEW_RELIC_ENABLE' => :agent_enabled,
+            'NEW_RELIC_ENABLED' => :agent_enabled
           }.each do |key, val|
             if ENV[key].to_s =~ /false|off|no/i
               self[val] = false

data/lib/new_relic/agent/cross_app_monitor.rb

@@ -87,7 +87,7 @@ module NewRelic
           end
         end
 
-        events.subscribe(:start_transaction) do |name|
+        events.subscribe(:start_transaction) do
           set_transaction_custom_parameters
         end
 
@@ -138,6 +138,7 @@ module NewRelic
 
       def insert_response_header(request_headers, response_headers)
         unless client_cross_app_id.nil?
+          NewRelic::Agent::Transaction.freeze_name
           timings = NewRelic::Agent::BrowserMonitoring.timings
           content_length = content_length_from_request(request_headers)
 

data/lib/new_relic/agent/cross_app_tracing.rb

@@ -52,7 +52,7 @@ module NewRelic
 
         # Create a segment and time the call
         t0 = Time.now
-        segment = stats_engine.push_scope( "External/#{http.address}/all", t0 )
+        segment = stats_engine.push_scope( :net_http, t0 )
 
         return t0, segment
       rescue => err
@@ -78,13 +78,13 @@ module NewRelic
             stats_engine.record_metrics(scoped_metric, duration, :scoped => true)
 
             # Add TT custom parameters
-            stats_engine.rename_scope_segment( scoped_metric )
-            extract_custom_parameters( response ) if response_is_crossapp?( response )
+            segment.name = scoped_metric
+            add_transaction_trace_parameters(http, request, response)
           end
         ensure
           # We always need to pop the scope stack to avoid an inconsistent
           # state, which will prevent tracing of the whole transaction.
-          stats_engine.pop_scope( segment, duration, t1 )
+          stats_engine.pop_scope( segment, scoped_metric, t1 )
         end
       rescue NewRelic::Agent::CrossAppTracing::Error => err
         NewRelic::Agent.logger.debug "while cross app tracing", err
@@ -124,15 +124,21 @@ module NewRelic
         NewRelic::Agent.logger.debug "Not injecting x-process header", err
       end
 
+      def add_transaction_trace_parameters(http, request, response)
+        filtered_uri = NewRelic::Agent::URIUtil.filtered_uri_for(http, request)
+        transaction_sampler.add_segment_parameters(:uri => filtered_uri)
+        if response_is_crossapp?( response )
+          add_cat_transaction_trace_parameters( response )
+        end
+      end
+
 
       # Extract any custom parameters from +response+ if it's cross-application and
       # add them to the current TT node.
-      def extract_custom_parameters( response )
-
+      def add_cat_transaction_trace_parameters( response )
         appdata = extract_appdata( response )
-        sampler = NewRelic::Agent.instance.transaction_sampler
-        sampler.add_segment_parameters( :transaction_guid => appdata[APPDATA_TXN_GUID_INDEX] )
-
+        transaction_sampler.add_segment_parameters( \
+          :transaction_guid => appdata[APPDATA_TXN_GUID_INDEX] )
       end
 
 
@@ -164,7 +170,7 @@ module NewRelic
         metrics = [ "External/all" ]
         metrics << "External/#{http.address}/all"
 
-        if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
+        if NewRelic::Agent::Transaction.recording_web_transaction?
           metrics << "External/allWeb"
         else
           metrics << "External/allOther"
@@ -246,6 +252,9 @@ module NewRelic
         NewRelic::Agent.instance.stats_engine
       end
 
+      def transaction_sampler
+        NewRelic::Agent.instance.transaction_sampler
+      end
 
       # Check the given +id+ to ensure it conforms to the format of a cross-application
       # ID. Raises an NewRelic::Agent::CrossAppTracing::Error if it doesn't.

data/lib/new_relic/agent/error_collector.rb

@@ -110,13 +110,14 @@ module NewRelic
 
         # Increments a statistic that tracks total error rate
         # Be sure not to double-count same exception. This clears per harvest.
-        def increment_error_count!(exception)
+        def increment_error_count!(exception, options={})
           return if seen?(exception)
           tag_as_seen(exception)
 
-          txn_info = NewRelic::Agent::TransactionInfo.get
           metric_names = ["Errors/all"]
-          metric_names << "Errors/#{txn_info.transaction_name}" if txn_info.transaction_name_set?
+          if options[:metric] && options[:metric] != '(unknown)'
+            metric_names << "Errors/#{options[:metric]}"
+          end
           stats_engine = NewRelic::Agent.agent.stats_engine
           stats_engine.record_metrics(metric_names) do |stats|
             stats.increment_count
@@ -129,7 +130,6 @@ module NewRelic
         def should_exit_notice_error?(exception)
           if enabled?
             if !error_is_ignored?(exception)
-              increment_error_count!(exception)
               return exception.nil? # exit early if the exception is nil
             end
           end
@@ -251,6 +251,7 @@ module NewRelic
       # If exception is nil, the error count is bumped and no traced error is recorded
       def notice_error(exception, options={})
         return if should_exit_notice_error?(exception)
+        increment_error_count!(exception, options)
         NewRelic::Agent.instance.events.notify(:notice_error, exception, options)
         action_path     = fetch_from_options(options, :metric, (NewRelic::Agent.instance.stats_engine.scope_name || ''))
         exception_options = error_params_from_options(options).merge(exception_info(exception))

data/lib/new_relic/agent/instrumentation/action_controller_subscriber.rb

@@ -0,0 +1,204 @@
+# 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/evented_subscriber'
+begin
+  require 'rack'
+rescue LoadError => e
+  Agent.logger.debug(e)
+end
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActionControllerSubscriber < EventedSubscriber
+        def initialize
+          super
+          NewRelic::Agent.instance.events.subscribe(:before_call) do |env|
+
+            request = begin
+                        ::Rack::Request.new(env)
+                      rescue => e
+                        Agent.logger.debug("Error creating Rack::Request object: #{e}")
+                        nil
+                      end
+            TransactionInfo.reset(request)
+          end
+        end
+
+        def start(name, id, payload)
+          payload[:request] = TransactionInfo.get.request
+          event = ControllerEvent.new(name, Time.now, nil, id, payload)
+          push_event(event)
+
+          if NewRelic::Agent.is_execution_traced? && !event.ignored?
+            start_transaction(event)
+          else
+            # if this transaction is ignored, make sure child
+            # transaction are also ignored
+            NewRelic::Agent.instance.push_trace_execution_flag(false)
+          end
+        end
+
+        def finish(name, id, payload)
+          event = pop_event(id)
+          event.payload.merge!(payload)
+
+          set_enduser_ignore if event.enduser_ignored?
+
+          if NewRelic::Agent.is_execution_traced? && !event.ignored?
+            event.finalize_metric_name!
+            record_queue_time(event)
+            record_metrics(event)
+            record_apdex(event)
+            record_instance_busy(event)
+            stop_transaction(event)
+          else
+            Agent.instance.pop_trace_execution_flag
+          end
+        end
+
+        def set_enduser_ignore
+          TransactionInfo.get.ignore_end_user = true
+        end
+
+        def record_metrics(event)
+          controller_metric = MetricSpec.new(event.metric_name)
+          txn = Transaction.current
+          metrics = [ 'HttpDispatcher']
+          if txn.has_parent?
+            controller_metric.scope = StatsEngine::MetricStats::SCOPE_PLACEHOLDER
+            record_metric_on_parent_transaction(controller_metric, event.duration)
+          end
+          metrics << controller_metric.dup
+
+          Agent.instance.stats_engine.record_metrics(metrics, event.duration)
+        end
+
+        def record_metric_on_parent_transaction(metric, time)
+          Agent.instance.stats_engine.transaction_stats_stack[-2] \
+            .record(metric, time)
+        end
+
+        def record_apdex(event)
+          return if event.apdex_ignored?
+          metric_parser = MetricParser::MetricParser \
+            .for_metric_named(event.metric_name)
+          duration_plus_queue_time = event.end - (event.queue_start || event.time)
+          Transaction.record_apdex(metric_parser,
+                                   event.duration,
+                                   duration_plus_queue_time,
+                                   event.exception_encountered?)
+        end
+
+        def record_instance_busy(event)
+          BusyCalculator.dispatcher_start(event.time)
+          BusyCalculator.dispatcher_finish(event.end)
+        end
+
+        def record_queue_time(event)
+          return unless event.queue_start
+          QueueTime.record_frontend_metrics(event.queue_start, event.time)
+        end
+
+        def start_transaction(event)
+          txn = Transaction.start(:controller,
+                                  :request => event.payload[:request],
+                                  :filtered_params => filter(event.payload[:params]))
+          txn.apdex_start = (event.queue_start || event.time)
+          event.scope = Agent.instance.stats_engine \
+            .push_scope(:action_controller, event.time)
+        end
+
+        def stop_transaction(event)
+          TransactionInfo.get.transaction.name = event.metric_name
+          Agent.instance.stats_engine \
+            .pop_scope(event.scope, event.metric_name, event.end)
+          Transaction.stop
+        end
+
+        def filter(params)
+          filters = Rails.application.config.filter_parameters
+          ActionDispatch::Http::ParameterFilter.new(filters).filter(params)
+        end
+      end
+
+      class ControllerEvent < Event
+        attr_accessor :parent, :scope
+        attr_reader :queue_start
+
+        def initialize(name, start, ending, transaction_id, payload)
+          super
+
+          @controller_class = payload[:controller].split('::') \
+            .inject(Object){|m,o| m.const_get(o)}
+
+          if payload[:request] && payload[:request].respond_to?(:env)
+            @queue_start = QueueTime.parse_frontend_timestamp(payload[:request].env, self.time)
+          end
+        end
+
+        def metric_name
+          @metric_name || "Controller/#{metric_path}/#{metric_action}"
+        end
+
+        def finalize_metric_name!
+          txn = NewRelic::Agent::Transaction.current
+
+          # the event provides the default name but the transaction has the final say
+          txn.name ||= metric_name
+
+          # this applies the transaction name rules if not already applied
+          txn.freeze_name
+          @metric_name = txn.name
+          return @metric_name
+        end
+
+        def metric_path
+          @controller_class.controller_path
+        end
+
+        def metric_action
+          payload[:action]
+        end
+
+        def ignored?
+          _is_filtered?('do_not_trace')
+        end
+
+        def apdex_ignored?
+          _is_filtered?('ignore_apdex')
+        end
+
+        def enduser_ignored?
+          _is_filtered?('ignore_enduser')
+        end
+
+        def exception_encountered?
+          payload[:exception]
+        end
+
+        # FIXME: shamelessly ripped from ControllerInstrumentation
+        def _is_filtered?(key)
+          if @controller_class.respond_to? :newrelic_read_attr
+            ignore_actions = @controller_class.newrelic_read_attr(key)
+          end
+
+          case ignore_actions
+          when nil; false
+          when Hash
+            only_actions = Array(ignore_actions[:only])
+            except_actions = Array(ignore_actions[:except])
+            only_actions.include?(metric_action.to_sym) || (except_actions.any? && !except_actions.include?(metric_action.to_sym))
+          else
+            true
+          end
+        end
+
+        def to_s
+          "#<NewRelic::Agent::Instrumentation::ControllerEvent:#{object_id} name: \"#{name}\" id: #{transaction_id} payload: #{payload}}>"
+        end
+      end
+    end
+  end
+end