newrelic_rpm 3.8.1.221 → 3.9.0.229

data/.gitignore

@@ -23,3 +23,4 @@ lib/new_relic/build.rb
 .tm_properties
 .bundle
 .yardoc
+artifacts/

data/.yardopts

@@ -5,7 +5,9 @@ lib/new_relic/agent/method_tracer.rb
 lib/new_relic/agent/instrumentation/controller_instrumentation.rb
 lib/new_relic/agent/instrumentation/rack.rb
 lib/new_relic/agent/instrumentation/metric_frame.rb
+lib/new_relic/agent/sql_sampler.rb
 lib/new_relic/agent/transaction.rb
+lib/new_relic/agent/transaction_sampler.rb
 lib/new_relic/rack/developer_mode.rb
 lib/new_relic/rack/agent_hooks.rb
 lib/new_relic/rack/browser_monitoring.rb

data/CHANGELOG

@@ -1,5 +1,100 @@
 # New Relic Ruby Agent Release Notes #
 
+## v3.9.0 ##
+
+  * Rack middleware instrumentation
+
+  The Ruby agent now automatically instruments Rack middlewares!
+
+  This means that the agent can now give you a more complete picture of your
+  application's response time, including time spent in middleware. It also means
+  that requests which previously weren't captured by the agent because they
+  never made it to the bottom of your middleware stack (usually a Rails or
+  Sinatra application) will now be captured.
+
+  After installing this version of the Ruby agent, you'll see a new 'Middleware'
+  band on your application's overview graph, and individual middlewares will
+  appear in transaction breakdown charts and transaction traces.
+
+  The agent can instrument middlewares that are added from a config.ru file via
+  Rack::Builder, or via Rails' middleware stack in Rails 3.0+.
+
+  This instrumentation may be disabled with the
+  disable_middlware_instrumentation configuration setting.
+
+  For more details, see the documentation for this feature:
+
+    - http://docs.newrelic.com/docs/ruby/rack-middlewares
+    - http://docs.newrelic.com/docs/ruby/middleware-upgrade-changes
+
+  * Capistrano 3.x support
+
+  Recording application deployments using Capistrano 3.x is now supported.
+
+  Many thanks to Jennifer Page for the contribution!
+
+  * Better support for Sidekiq's Delayed extensions
+
+  Sidekiq jobs executed via the Delayed extensions (e.g. the #delay method) will
+  now be named after the actual class that #delay was invoked against, and will
+  have their job arguments correctly captured if the sidekiq.capture_params
+  configuration setting is enabled.
+
+  Many thanks to printercu for the contribution!
+
+  * Improved Apdex calculation with ignored error classes
+
+  Previously, a transaction resulting in an exception that bubbled up to the top
+  level would always be counted as failing for the purposes of Apdex
+  calculations (unless the transaction name was ignored entirely). Now,
+  exceptions whose classes have been ignored by the
+  error_collector.ignore_errors configuration setting will not cause a
+  transaction to be automatically counted as failing.
+
+  * Allow URIs that are not parseable by stdlib's URI if addressable is present
+
+  There are some URIs that are valid by RFC 3986, but not parseable by Ruby's
+  stdlib URI class. The Ruby agent will now attempt to use the addressable gem
+  to parse URIs if it is present, allowing requests against these problematic
+  URIs to be instrumented.
+
+  Many thanks to Craig R Webster and Amir Yalon for their help with this issue!
+
+  * More robust error collection from Resque processes
+
+  Previously, traced errors where the exception class was defined in the Resque
+  worker but not in the Resque master process would not be correctly handled by
+  the agent. This has been fixed.
+
+  * Allow Sinatra apps to set the New Relic environment without setting RACK_ENV
+
+  The NEW_RELIC_ENV environment variable may now be used to specify the
+  environment the agent should use from its configuration file, independently of
+  RACK_ENV.
+
+  Many thanks to Mario Izquierdo for the contribution!
+
+  * Better error handling in Browser Application Monitoring injection
+
+  The agent middleware that injects the JavaScript code necessary for Browser
+  Application Monitoring now does a better job of catching errors that might
+  occur during the injection process.
+
+  * Allow disabling of Net::HTTP instrumentation
+
+  Most instrumentation in the Ruby agent can be disabled easily via a
+  configuration setting. Our Net::HTTP instrumentation was previously an
+  exception, but now it can also be disabled with the disable_net_http
+  configuration setting.
+
+  * Make Rails constant presence check more defensive
+
+  The Ruby agent now guards against the (rare) case where an application has a
+  Rails constant defined, but no Rails::VERSION constant (because Rails is not
+  actually present).
+
+  Many thanks to Vladimir Kiselev for the contribution!
+
 ## v3.8.1 ##
 
   * Better handling for Rack applications implemented as middlewares

data/README.md

@@ -111,8 +111,8 @@ to your startup sequence and then manually start the agent using
 
     NewRelic::Agent.manual_start
 
-To instrument Rack based applications, refer to the docs in
-`NewRelic::Agent::Instrumentation::Rack`.
+For information about instrumenting pure Rack applications, see our
+[Rack middlewares documentation](http://docs.newrelic.com/docs/ruby/rack-middlewares).
 
 Refer to the [New Relic's Docs](http://newrelic.com/docs) for details on how to
 monitor other web frameworks, background jobs, and daemons.
@@ -120,7 +120,7 @@ monitor other web frameworks, background jobs, and daemons.
 The Ruby Agent provides an API that allows custom instrumentation of additional
 frameworks.  You can find a list of community created intrumentation plugins
 (e.g. [newrelic-redis](https://github.com/evanphx/newrelic-redis)) in the
-[RPM Contrib README](https://github.com/newrelic/rpm_contrib/blob/master/README.md#new-relic-ruby-agent-plugins-seperate-projects).
+[extends_newrelic_rpm project](https://github.com/newrelic/extends_newrelic_rpm).
 
 ## Developer Mode
 
@@ -171,6 +171,12 @@ analysis. To view this data, log in to http://rpm.newrelic.com.
 NOTE: You must have a valid account and license key to view this data
 online.  Refer to instructions in *Getting Started*.
 
+## Recording Deploys
+
+The Ruby Agent supports recording deployments in New Relic via a command line
+tool or Capistrano recipes. For more information on these features see
+[our deployment documentation](http://docs.newrelic.com/docs/ruby/recording-deployments-with-the-ruby-agent)
+for more information.
 
 ## Support
 

data/Rakefile

@@ -37,6 +37,12 @@ namespace :test do
     ruby test_files.join(" ")
   end
 
+  task 'multiverse:prime', [:suite] => [] do |t, args|
+    require File.expand_path(File.join(File.dirname(__FILE__), 'test', 'multiverse', 'lib', 'multiverse', 'environment'))
+    opts = Multiverse::Runner.parse_args(args)
+    Multiverse::Runner.prime(args.suite, opts)
+  end
+
   desc "Run agent performance tests"
   task :performance, [:suite, :name] => [] do |t, args|
     require File.expand_path(File.join(File.dirname(__FILE__), 'test', 'performance', 'lib', 'performance'))

data/lib/new_relic/agent.rb

@@ -23,7 +23,7 @@ require 'new_relic/control'
 #
 # == Using with Rack/Metal
 #
-# To instrument Rack middlwares or Metal apps, refer to the docs in
+# To instrument Rack middlewares or Metal apps, refer to the docs in
 # NewRelic::Agent::Instrumentation::Rack.
 #
 # == Ruby Agent API
@@ -118,8 +118,6 @@ module NewRelic
     require 'thread'
     require 'resolv'
 
-    extend NewRelic::Agent::Configuration::Instance
-
     # An exception that is thrown by the server if the agent license is invalid.
     class LicenseException < StandardError; end
 
@@ -171,6 +169,19 @@ module NewRelic
       @logger = log
     end
 
+    # This needs to come after the definition of the logger method above, since
+    # instantiating the config writes to the Logger.
+
+    @config = NewRelic::Agent::Configuration::Manager.new
+
+    attr_reader :config
+
+    # For testing
+    # Important that we don't change the instance or we orphan callbacks
+    def reset_config
+      @config.reset_to_defaults
+    end
+
     # Record a value for the given metric name.
     #
     # This method should be used to record event-based metrics such as method
@@ -187,7 +198,7 @@ module NewRelic
     # This method is safe to use from any thread.
     #
     # @api public
-    def record_metric(metric_name, value)
+    def record_metric(metric_name, value) #THREAD_LOCAL_ACCESS
       if value.is_a?(Hash)
         stats = NewRelic::Agent::Stats.new
 
@@ -199,7 +210,7 @@ module NewRelic
         stats.sum_of_squares = value[:sum_of_squares] if value[:sum_of_squares]
         value = stats
       end
-      agent.stats_engine.record_metrics(metric_name, value)
+      agent.stats_engine.tl_record_unscoped_metrics(metric_name, value)
     end
 
     # Increment a simple counter metric.
@@ -210,8 +221,8 @@ module NewRelic
     # This method is safe to use from any thread.
     #
     # @api public
-    def increment_metric(metric_name, amount=1)
-      agent.stats_engine.record_metrics(metric_name) do |stats|
+    def increment_metric(metric_name, amount=1) #THREAD_LOCAL_ACCESS
+      agent.stats_engine.tl_record_unscoped_metrics(metric_name) do |stats|
         stats.increment_count(amount)
       end
     end
@@ -407,20 +418,20 @@ module NewRelic
     end
 
     # Check to see if we are capturing metrics currently on this thread.
-    def is_execution_traced?
-      NewRelic::Agent::TransactionState.get.is_traced?
+    def tl_is_execution_traced?
+      NewRelic::Agent::TransactionState.tl_get.is_execution_traced?
     end
 
     # helper method to check the thread local to determine whether the
     # transaction in progress is traced or not
-    def is_transaction_traced?
-      NewRelic::Agent::TransactionState.get.is_transaction_traced?
+    def tl_is_transaction_traced?
+      NewRelic::Agent::TransactionState.tl_get.is_transaction_traced?
     end
 
     # helper method to check the thread local to determine whether sql
     # is being recorded or not
-    def is_sql_recorded?
-      NewRelic::Agent::TransactionState.get.is_sql_recorded?
+    def tl_is_sql_recorded?
+      NewRelic::Agent::TransactionState.tl_get.is_sql_recorded?
     end
 
     # Set a filter to be applied to errors that the Ruby Agent will
@@ -467,9 +478,10 @@ module NewRelic
     #
     # @api public
     #
-    def add_custom_parameters(params)
+    def add_custom_parameters(params) #THREAD_LOCAL_ACCESS
       if params.is_a? Hash
-        Transaction.add_custom_parameters(params)
+        txn = Transaction.tl_current
+        txn.add_custom_parameters(params) if txn
       else
         ::NewRelic::Agent.logger.warn("Bad argument passed to #add_custom_parameters. Expected Hash but got #{params.class}")
       end
@@ -492,7 +504,7 @@ module NewRelic
     # * <tt>:category => :task</tt> indicates that this is a
     #   background task and will show up in New Relic with other background
     #   tasks instead of in the controllers list
-    # * <tt>:category => :rack</tt> if you are instrumenting a rack
+    # * <tt>:category => :middleware</tt> if you are instrumenting a rack
     #   middleware call.  The <tt>:name</tt> is optional, useful if you
     #   have more than one potential transaction in the #call.
     # * <tt>:category => :uri</tt> indicates that this is a
@@ -513,10 +525,11 @@ module NewRelic
     #
     # @api public
     #
-    def get_transaction_name
-      if Transaction.current
+    def get_transaction_name #THREAD_LOCAL_ACCESS
+      txn = Transaction.tl_current
+      if txn
         namer = Instrumentation::ControllerInstrumentation::TransactionNamer
-        Transaction.current.best_name.sub(Regexp.new("\\A#{Regexp.escape(namer.category_name)}/"), '')
+        txn.best_name.sub(Regexp.new("\\A#{Regexp.escape(namer.prefix_for_category(txn))}"), '')
       end
     end
 
@@ -531,45 +544,17 @@ module NewRelic
     #
     # @api public
     #
-    def with_database_metric_name(model, method, &block)
-      if txn = Transaction.current
+    def with_database_metric_name(model, method, &block) #THREAD_LOCAL_ACCESS
+      if txn = Transaction.tl_current
         txn.with_database_metric_name(model, method, &block)
       else
         yield
       end
     end
 
-    # Record a web transaction from an external source.  This will
-    # process the response time, error, and score an apdex value.
-    #
-    # First argument is a float value, time in seconds.  Option
-    # keys are strings.
-    #
-    # == Identifying the transaction
-    # * <tt>'uri' => uri</tt> to record the value for a given web request.
-    #   If not provided, just record the aggregate dispatcher and apdex scores.
-    # * <tt>'metric' => metric_name</tt> to record with a general metric name
-    #   like +OtherTransaction/Background/Class/method+.  Ignored if +uri+ is
-    #   provided.
-    #
-    # == Error options
-    # Provide one of the following:
-    # * <tt>'is_error' => true</tt> if an unknown error occurred
-    # * <tt>'error_message' => msg</tt> if an error message is available
-    # * <tt>'exception' => exception</tt> if a ruby exception is recorded
-    #
-    # == Misc options
-    # Additional information captured in errors
-    # * <tt>'referer' => referer_url</tt>
-    # * <tt>'request_params' => hash</tt> to record a set of name/value pairs as the
-    #   request parameters.
-    # * <tt>'custom_params' => hash</tt> to record extra information in traced errors
-    #
-    # @api public
-    # @deprecated
-    #
-    def record_transaction(response_sec, options = {})
-      agent.record_transaction(response_sec, options)
+    # Remove after 5/9/15
+    def record_transaction(*args)
+      NewRelic::Agent.logger.warn('This method has been deprecated, please see https://docs.newrelic.com/docs/ruby/ruby-agent-api for current API documentation.')
     end
 
     # Subscribe to events of +event_type+, calling the given +handler+

data/lib/new_relic/agent/agent.rb

@@ -11,6 +11,7 @@ require 'stringio'
 require 'new_relic/agent/sampled_buffer'
 require 'new_relic/agent/autostart'
 require 'new_relic/agent/harvester'
+require 'new_relic/agent/hostname'
 require 'new_relic/agent/new_relic_service'
 require 'new_relic/agent/pipe_service'
 require 'new_relic/agent/configuration/manager'
@@ -32,14 +33,14 @@ module NewRelic
     # in realtime as the application runs, and periodically sends that
     # data to the NewRelic server.
     class Agent
-      extend NewRelic::Agent::Configuration::Instance
+      def self.config
+        ::NewRelic::Agent.config
+      end
 
       def initialize
         # FIXME: temporary work around for RUBY-839
         # This should be handled with a configuration callback
-        if Agent.config[:monitor_mode]
-          @service = NewRelic::Agent::NewRelicService.new
-        end
+        start_service_if_needed
 
         @events                = NewRelic::Agent::EventListener.new
         @stats_engine          = NewRelic::Agent::StatsEngine.new
@@ -112,42 +113,6 @@ module NewRelic
         # GC::Profiler.total_time is not monotonic so we wrap it.
         attr_reader :monotonic_gc_profiler
 
-        # fakes out a transaction that did not happen in this process
-        # by creating apdex, summary metrics, and recording statistics
-        # for the transaction
-        #
-        # This method is *deprecated* - it may be removed in future
-        # versions of the agent
-        def record_transaction(duration_seconds, options={})
-          is_error = options['is_error'] || options['error_message'] || options['exception']
-          metric = options['metric']
-          metric ||= options['uri'] # normalize this with url rules
-          raise "metric or uri arguments required" unless metric
-          metric_info = NewRelic::MetricParser::MetricParser.for_metric_named(metric)
-
-          if metric_info.is_web_transaction?
-            NewRelic::Agent::Transaction.record_apdex(metric_info, duration_seconds, duration_seconds, is_error)
-          end
-          metrics = metric_info.summary_metrics
-
-          metrics << metric
-          metrics.each do |name|
-            NewRelic::Agent.record_metric(name, duration_seconds)
-          end
-
-          if is_error
-            if options['exception']
-              e = options['exception']
-            elsif options['error_message']
-              e = StandardError.new options['error_message']
-            else
-              e = StandardError.new 'Unknown Error'
-            end
-            error_collector.notice_error e, :uri => options['uri'], :metric => metric
-          end
-          # busy time ?
-        end
-
         # This method should be called in a forked process after a fork.
         # It assumes the parent process initialized the agent, but does
         # not assume the agent started.
@@ -172,7 +137,7 @@ module NewRelic
           # we should be ready to run and shouldn't restarting if we can't.
           @harvester.mark_started
 
-          Agent.config.apply_config(NewRelic::Agent::Configuration::ManualSource.new(options), 1)
+          Agent.config.replace_or_add_config(NewRelic::Agent::Configuration::ManualSource.new(options))
 
           if channel_id = options[:report_to_channel]
             @service = NewRelic::Agent::PipeService.new(channel_id)
@@ -223,10 +188,8 @@ module NewRelic
         end
 
         def revert_to_default_configuration
-          NewRelic::Agent.config.remove_config do |config|
-            config.class == NewRelic::Agent::Configuration::ManualSource ||
-              config.class == NewRelic::Agent::Configuration::ServerSource
-          end
+          NewRelic::Agent.config.remove_config_type(:manual)
+          NewRelic::Agent.config.remove_config_type(:server)
         end
 
         def stop_worker_loop
@@ -258,18 +221,20 @@ module NewRelic
         # Sets a thread local variable as to whether we should or
         # should not record sql in the current thread. Returns the
         # previous value, if there is one
-        def set_record_sql(should_record)
-          prev = TransactionState.get.record_sql
-          TransactionState.get.record_sql = should_record
+        def set_record_sql(should_record) #THREAD_LOCAL_ACCESS
+          state = TransactionState.tl_get
+          prev = state.record_sql
+          state.record_sql = should_record
           prev.nil? || prev
         end
 
         # Sets a thread local variable as to whether we should or
         # should not record transaction traces in the current
         # thread. Returns the previous value, if there is one
-        def set_record_tt(should_record)
-          prev = TransactionState.get.record_tt
-          TransactionState.get.record_tt = should_record
+        def set_record_tt(should_record) #THREAD_LOCAL_ACCESS
+          state = TransactionState.tl_get
+          prev = state.record_tt
+          state.record_tt = should_record
           prev.nil? || prev
         end
 
@@ -277,14 +242,14 @@ module NewRelic
         # thread. This uses a stack which allows us to disable tracing
         # children of a transaction without affecting the tracing of
         # the whole transaction
-        def push_trace_execution_flag(should_trace=false)
-          TransactionState.get.push_traced(should_trace)
+        def push_trace_execution_flag(should_trace=false) #THREAD_LOCAL_ACCESS
+          TransactionState.tl_get.push_traced(should_trace)
         end
 
         # Pop the current trace execution status.  Restore trace execution status
         # to what it was before we pushed the current flag.
-        def pop_trace_execution_flag
-          TransactionState.get.pop_traced
+        def pop_trace_execution_flag #THREAD_LOCAL_ACCESS
+          TransactionState.tl_get.pop_traced
         end
 
         # Herein lies the corpse of the former 'start' method. May
@@ -385,6 +350,12 @@ module NewRelic
             end
           end
 
+          def start_service_if_needed
+            if Agent.config[:monitor_mode] && !@service
+              @service = NewRelic::Agent::NewRelicService.new
+            end
+          end
+
           # Classy logging of the agent version and the current pid,
           # so we can disambiguate processes in the log file and make
           # sure they're running a reasonable version
@@ -670,14 +641,13 @@ module NewRelic
         #
         # See #connect for a description of connection_options.
         def start_worker_thread(connection_options = {})
-          disable = NewRelic::Agent.config[:disable_harvest_thread]
-          if disable
+          if disable = NewRelic::Agent.config[:disable_harvest_thread]
             NewRelic::Agent.logger.info "Not starting Ruby Agent worker thread because :disable_harvest_thread is #{disable}"
             return
           end
 
           ::NewRelic::Agent.logger.debug "Creating Ruby Agent worker thread."
-          @worker_thread = NewRelic::Agent::Threading::AgentThread.new('Worker Loop') do
+          @worker_thread = NewRelic::Agent::Threading::AgentThread.create('Worker Loop') do
             deferred_work!(connection_options)
           end
         end
@@ -826,7 +796,7 @@ module NewRelic
 
             ::NewRelic::Agent.logger.debug "Server provided config: #{config_data.inspect}"
             server_config = NewRelic::Agent::Configuration::ServerSource.new(config_data, Agent.config)
-            Agent.config.replace_or_add_config(server_config, 1)
+            Agent.config.replace_or_add_config(server_config)
             log_connection!(config_data) if @service
 
             @transaction_rules = RulesEngine.from_specs(config_data['transaction_name_rules'])
@@ -908,7 +878,7 @@ module NewRelic
           handle_license_error(e)
         rescue NewRelic::Agent::UnrecoverableAgentException => e
           handle_unrecoverable_agent_error(e)
-        rescue Timeout::Error, NewRelic::Agent::ServerConnectionException => e
+        rescue StandardError, Timeout::Error, NewRelic::Agent::ServerConnectionException => e
           log_error(e)
           if opts[:keep_retrying]
             note_connect_failure
@@ -918,13 +888,11 @@ module NewRelic
           else
             disconnect
           end
-        rescue StandardError => e
-          handle_other_error(e)
         end
 
         # Who am I? Well, this method can tell you your hostname.
         def determine_host
-          Socket.gethostname
+          NewRelic::Agent::Hostname.get
         end
 
         def local_host
@@ -1053,7 +1021,7 @@ module NewRelic
         ensure
           NewRelic::Agent::Database.close_connections
           duration = (Time.now - now).to_f
-          @stats_engine.record_metrics('Supportability/Harvest', duration)
+          NewRelic::Agent.record_metric('Supportability/Harvest', duration)
         end
 
         private :transmit_data_already_locked