newrelic_rpm 3.6.5.130 → 3.6.6.147

data/CHANGELOG

@@ -1,5 +1,29 @@
 # New Relic Ruby Agent Release Notes #
 
+## v3.6.6 ##
+
+  * HTTPClient and Curb support
+
+  The Ruby agent now supports the HTTPClient and Curb HTTP libraries! Cross
+  application tracing and more is fully supported for these libraries. For more
+  details see https://newrelic.com/docs/ruby/ruby-http-clients.
+
+  * Sinatra startup improvements
+
+  In earlier agent versions, newrelic_rpm had to be required after Sinatra to
+  get instrumentation. Now the agent should start when your Sinatra app starts
+  up in rackup, thin, unicorn, or similar web servers.
+
+  * Puma clustered mode support
+
+  Clustered mode in Puma was not reporting data without manually adding a hook
+  to Puma's configuration. The agent will now automatically add this hook.
+
+  * SSL certificate verification
+
+  Early versions of the agent's SSL support provided an option to skip
+  certificate verification. This option has been removed.
+
 ## v3.6.5 ##
 
   * Rails 4.0 Support
@@ -121,8 +145,8 @@
 
   * Added NewRelic::Agent.set_transaction_name and NewRelic::Agent.get_transaction_name
 
-  Ordinarily the name of your transaction is defined up-front, but if you'd like to 
-  change the name of a transaction while it is still running you can use 
+  Ordinarily the name of your transaction is defined up-front, but if you'd like to
+  change the name of a transaction while it is still running you can use
   **NewRelic::Agent.set_transaction_name()**.  Similarly, if you need to know the name
   of the currently running transaction, you can use **NewRelic::Agent.get_transaction_name()**.
 
@@ -274,7 +298,7 @@
     The agent can now log all of the data it sends to the New Relic servers to
     a special log file for human inspection. This feature is off by default, and
     can be enabled by setting the audit_log.enabled configuration key to true.
-    You may also control the location of the audit log with the audit_log.path key. 
+    You may also control the location of the audit log with the audit_log.path key.
 
   * Use config system for dispatcher, framework, and config file detection
 

data/Gemfile

@@ -1,16 +1,3 @@
 source 'https://rubygems.org'
 
-group :development do
-  # require 0.9.6.
-  # There's problems with the test task in rake 10
-  # https://github.com/jimweirich/rake/issues/144
-  gem 'rake', '0.9.6'
-  gem 'mocha', '~>0.13.0', :require => false
-  gem 'sdoc-helpers'
-  gem 'rdoc', '>= 2.4.2'
-  gem 'rails', '~>3.2.13'
-  gem 'sqlite3', :platform => 'mri'
-  gem 'activerecord-jdbcsqlite3-adapter', :platform => 'jruby'
-  gem 'jruby-openssl', :platform => 'jruby'
-  gem 'sequel', '~> 3.46.0'
-end
+gemspec

data/Rakefile

@@ -22,12 +22,13 @@ namespace :test do
   agent_home = File.expand_path(File.dirname(__FILE__))
 
   desc "Run functional test suite for newrelic"
-  task :multiverse, [:suite, :mode] => [] do |t, args|
-    args.with_defaults(:suite => "", :mode => "")
-    if args.mode == "run_one"
-      puts `#{agent_home}/test/multiverse/script/run_one #{args.suite}`
+  task :multiverse, [:suite, :param1, :param2, :param3, :param4] => [] do |t, args|
+    require File.expand_path(File.join(File.dirname(__FILE__), 'test', 'multiverse', 'lib', 'multiverse', 'environment'))
+    opts = Multiverse::Runner.parse_args(args)
+    if opts.key?(:run_one)
+      Multiverse::Runner.run_one(args.suite, opts)
     else
-      ruby "#{agent_home}/test/multiverse/script/runner #{args.suite}"
+      Multiverse::Runner.run(args.suite, opts)
     end
   end
 
@@ -39,6 +40,15 @@ namespace :test do
     ruby test_files.join(" ")
   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'))
+    options = {}
+    options[:suite] = args[:suite] if args[:suite]
+    options[:name]  = args[:name]  if args[:name]
+    Performance::Runner.new(options).run_and_report
+  end
+
   Rake::TestTask.new(:intentional_fail) do |t|
     t.libs << "#{agent_home}/test"
     t.libs << "#{agent_home}/lib"

data/config.dot

@@ -155,7 +155,7 @@ digraph AgentEnabled {
   "Control#init_plugin" -> "[agent_enabled]"
   "Control#init_plugin" -> "Control#setup_log"
   "Control#init_plugin" -> "[disable_samplers]"
-  "Control#should_log?" -> "[agent_enabled]" 
+  "Control#should_log?" -> "[agent_enabled]"
   "Control#api_server" -> "[api_host]"
   "Control#api_server" -> "[api_port]"
   "Control#proxy_server" -> "[proxy_host]"

data/lib/new_relic/agent/agent.rb

@@ -474,11 +474,20 @@ module NewRelic
 
         include Start
 
+        def defer_for_delayed_job?
+          NewRelic::Agent.config[:dispatcher] == :delayed_job &&
+            !NewRelic::DelayedJobInjection.worker_name
+        end
 
         # Check to see if the agent should start, returning +true+ if it should.
         def agent_should_start?
           return false if already_started? || disabled?
 
+          if defer_for_delayed_job?
+            ::NewRelic::Agent.logger.debug "Deferring startup for DelayedJob"
+            return false
+          end
+
           if defer_for_resque?
             ::NewRelic::Agent.logger.debug "Deferring startup for Resque in case it daemonizes"
             return false
@@ -635,6 +644,12 @@ 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
+            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::AgentThread.new('Worker Loop') do
             deferred_work!(connection_options)

data/lib/new_relic/agent/agent_logger.rb

@@ -41,24 +41,29 @@ module NewRelic
         false
       end
 
-      # Allows for passing exceptions in explicitly, which format with backtrace
-      def format_and_send(level, *msgs)
-        msgs.flatten!
-        exceptions = msgs.find_all {|m| m.is_a?(Exception) }
-        msgs.collect! do |msg|
-          if msg.respond_to?(:message)
-            "%p: %s" % [ msg.class, msg.message ]
+      # Use this when you want to log an exception with explicit control over
+      # the log level that the backtrace is logged at. If you just want the
+      # default behavior of backtraces logged at debug, use one of the methods
+      # above and pass an Exception as one of the args.
+      def log_exception(level, e, backtrace_level=level)
+        @log.send(level, "%p: %s" % [ e.class, e.message ])
+        @log.send(backtrace_level) do
+          backtrace = e.backtrace
+          if backtrace
+            "Debugging backtrace:\n" + backtrace.join("\n  ")
           else
-            msg.to_s
+            "No backtrace available."
           end
         end
+      end
 
-        msgs.each do |msg|
-          @log.send level, msg
-        end
-
-        exceptions.each do |ex|
-          @log.debug { "Debugging backtrace:\n  " + ex.backtrace.join("\n  ") }
+      # Allows for passing exceptions in explicitly, which format with backtrace
+      def format_and_send(level, *msgs)
+        msgs.flatten.each do |item|
+          case item
+          when Exception then log_exception(level, item, :debug)
+          else @log.send(level, item)
+          end
         end
       end
 

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

@@ -39,7 +39,7 @@ module NewRelic
             when 4
               :rails4
             else
-              ::NewRelic::Agent::Agent.logger.error "Detected unsupported Rails version #{Rails::VERSION::STRING}"
+              ::NewRelic::Agent.logger.error "Detected unsupported Rails version #{Rails::VERSION::STRING}"
             end
           when defined?(::Sinatra) && defined?(::Sinatra::Base) then :sinatra
           when defined?(::NewRelic::IA) then :external
@@ -61,7 +61,7 @@ module NewRelic
         :'autostart.blacklisted_constants' => 'Rails::Console',
         # Comma separated 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_executables' => 'irb,rspec',
         :'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,
@@ -80,7 +80,6 @@ module NewRelic
         :port                   => Proc.new { self[:ssl] ? 443 : 80 },
         :api_port               => Proc.new { self[:port] },
         :ssl                    => true,
-        :verify_certificate     => true,
         :sync_startup           => false,
         :send_data_on_exit      => true,
         :post_size_limit        => 2 * 1024 * 1024, # 2 megs
@@ -108,11 +107,13 @@ module NewRelic
         :disable_sinatra_auto_middleware      => false,
         :disable_view_instrumentation         => false,
         :disable_backtrace_cleanup            => false,
+        :disable_harvest_thread               => false,
         :skip_ar_instrumentation              => false,
         :disable_activerecord_instrumentation => Proc.new { self[:skip_ar_instrumentation] },
         :disable_memcache_instrumentation     => false,
         :disable_mobile_headers               => true,
 
+        :capture_params        => false,
         :capture_memcache_keys => false,
         :textmate              => false,
 

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

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

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

@@ -18,8 +18,7 @@ module NewRelic
         attr_reader :config_stack, :stripped_exceptions_whitelist
 
         def initialize
-          @config_stack = [ EnvironmentSource.new, DEFAULTS ]
-          @cache = Hash.new {|hash,key| hash[key] = self.fetch(key) }
+          reset_to_defaults
           @callbacks = Hash.new {|hash,key| hash[key] = [] }
 
           register_callback(:'strip_exception_messages.whitelist') do |whitelist|
@@ -145,6 +144,12 @@ module NewRelic
           end
         end
 
+        # Generally only useful during initial construction and tests
+        def reset_to_defaults
+          @config_stack = [ EnvironmentSource.new, DEFAULTS ]
+          reset_cache
+        end
+
         def reset_cache
           @cache = Hash.new {|hash,key| hash[key] = self.fetch(key) }
         end

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

@@ -7,8 +7,7 @@ module NewRelic
     module Configuration
       MASK_DEFAULTS = {
         :'thread_profiler' =>         Proc.new { !NewRelic::Agent::ThreadProfiler.is_supported? },
-        :'thread_profiler.enabled' => Proc.new { !NewRelic::Agent::ThreadProfiler.is_supported? },
-        :verify_certificate =>  Proc.new{ true }
+        :'thread_profiler.enabled' => Proc.new { !NewRelic::Agent::ThreadProfiler.is_supported? }
       }
     end
   end

data/lib/new_relic/agent/cross_app_monitor.rb

@@ -189,10 +189,12 @@ module NewRelic
         # We expect to get the before call to set the id (if we have it) before
         # this, and then write our custom parameter when the transaction starts
         NewRelic::Agent.add_custom_parameters(:client_cross_process_id => client_cross_app_id()) if client_cross_app_id()
-        NewRelic::Agent.add_custom_parameters(:referring_transaction_guid => client_referring_transaction_guid()) if
-          client_referring_transaction_guid()
 
-        NewRelic::Agent.logger.debug "Referring transaction guid: %p" % [client_referring_transaction_guid()]
+        referring_guid = client_referring_transaction_guid()
+        if referring_guid
+          NewRelic::Agent.logger.debug "Referring transaction guid: %p" % [referring_guid]
+          NewRelic::Agent.add_custom_parameters(:referring_transaction_guid => referring_guid)
+        end
       end
 
       def set_error_custom_parameters(options)
@@ -237,4 +239,3 @@ module NewRelic
 
   end
 end
-

data/lib/new_relic/agent/cross_app_tracing.rb

@@ -301,4 +301,3 @@ module NewRelic
     end
   end
 end
-

data/lib/new_relic/agent/error_collector.rb

@@ -230,7 +230,7 @@ module NewRelic
         # checks the size of the error queue to make sure we are under
         # the maximum limit, and logs a warning if we are over the limit.
         def over_queue_limit?(message)
-          over_limit = (@errors.length >= MAX_ERROR_QUEUE_LENGTH)
+          over_limit = (@errors.reject{|err| err.exception_class_constant < NewRelic::Agent::InternalAgentError}.length >= MAX_ERROR_QUEUE_LENGTH)
           ::NewRelic::Agent.logger.warn("The error reporting queue has reached #{MAX_ERROR_QUEUE_LENGTH}. The error detail for this and subsequent errors will not be transmitted to New Relic until the queued errors have been sent: #{message}") if over_limit
           over_limit
         end
@@ -272,6 +272,35 @@ module NewRelic
         ::NewRelic::Agent.logger.warn("Failure when capturing error '#{exception}':", e)
       end
 
+      # *Use sparingly for difficult to track bugs.*
+      #
+      # Track internal agent errors for communication back to New Relic.
+      # To use, make a specific subclass of NewRelic::Agent::InternalAgentError,
+      # then pass an instance of it to this method when your problem occurs.
+      #
+      # Limits are treated differently for these errors. We only gather one per
+      # class per harvest, disregarding (and not impacting) the app error queue
+      # limit.
+      def notice_agent_error(exception)
+        return unless exception.class < NewRelic::Agent::InternalAgentError
+
+        # Log 'em all!
+        NewRelic::Agent.logger.info(exception)
+
+        @lock.synchronize do
+          # Already seen this class once? Bail!
+          return if @errors.any? { |err| err.exception_class_constant == exception.class }
+
+          trace = exception.backtrace || caller.dup
+          noticed_error = NewRelic::NoticedError.new("NewRelic/AgentError",
+                                                     {:stack_trace => trace},
+                                                     exception)
+          @errors << noticed_error
+        end
+      rescue => e
+        NewRelic::Agent.logger.info("Unable to capture internal agent error due to an exception:", e)
+      end
+
       # Get the errors currently queued up.  Unsent errors are left
       # over from a previous unsuccessful attempt to send them to the server.
       def harvest_errors(unsent_errors)

data/lib/new_relic/agent/http_clients/curb_wrappers.rb

@@ -0,0 +1,67 @@
+# 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
+    module HTTPClients
+
+      class CurbRequest
+        def initialize( curlobj )
+          @curlobj = curlobj
+        end
+
+        def type
+          'Curb'
+        end
+
+        def host
+          self.uri.host
+        end
+
+        def method
+          @curlobj._nr_http_verb
+        end
+
+        def []( key )
+          @curlobj.headers[ key ]
+        end
+
+        def []=( key, value )
+          @curlobj.headers[ key ] = value
+        end
+
+        def uri
+          @uri ||= URI( @curlobj.url )
+        end
+      end
+
+
+      class CurbResponse
+
+        def initialize(curlobj)
+          @headers = {}
+          @curlobj = curlobj
+        end
+
+        def [](key)
+          @headers[ key.downcase ]
+        end
+
+        def to_hash
+          @headers.dup
+        end
+
+        def append_header_data( data )
+          key, value = data.split( /:\s*/, 2 )
+          @headers[ key.downcase ] = value
+          @curlobj._nr_header_str ||= ''
+          @curlobj._nr_header_str << data
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/new_relic/agent/http_clients/httpclient_wrappers.rb

@@ -0,0 +1,59 @@
+# 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
+    module HTTPClients
+      class HTTPClientResponse
+        attr_reader :response
+
+        def initialize(response)
+          @response = response
+        end
+
+        def [](key)
+          response.headers.each do |k,v|
+            if key.downcase == k.downcase
+              return v
+            end
+          end
+          nil
+        end
+
+        def to_hash
+          response.headers
+        end
+      end
+
+      class HTTPClientRequest
+        attr_reader :request, :uri
+
+        def initialize(request)
+          @request = request
+          @uri = request.header.request_uri
+        end
+
+        def type
+          "HTTPClient"
+        end
+
+        def method
+          request.header.request_method
+        end
+
+        def host
+          uri.host.to_s
+        end
+
+        def [](key)
+          request.headers[key]
+        end
+
+        def []=(key, value)
+          request.http_header[key] = value
+        end
+      end
+    end
+  end
+end