wd_newrelic_rpm 3.5.5 → 3.5.6

data/.gitignore

@@ -18,3 +18,5 @@ tags
 /lerg/
 gems/newrelic_rpm.gemspec
 gems/newrelic_rpm*.tar.gz
+lib/new_relic/build.rb
+.pryrc

data/CHANGELOG

@@ -1,6 +1,66 @@
 
 # New Relic Ruby Agent Release Notes #
 
+## v3.5.6 ##
+
+  * Use HTTPS by default
+
+    The agent now defaults to using SSL when it communicates with New Relic's
+    servers.  By defaults already configured, New Relic does not transmit any
+    sensitive information (e.g. SQL parameters are masked), but SSL adds 
+    another layer of security.  Upgrading customers may need to remove the
+    "ssl: false" directive from their newrelic.yml to enable ssl.  Customers on
+    Jruby may need to install the jruby-openssl gem to take advantage of this
+    feature.
+
+  * Fix two Resque-related issues
+
+    Fixes a possible hang on exit of an instrumented Resque master process
+    (https://github.com/defunkt/resque/issues/578), as well as a file descriptor
+    leak that could occur during startup of the Resque master process.
+
+  * Fix for error graph over 100%
+
+    Some errors were double counted toward the overall error total. This
+    resulted in graphs with error percentages over 100%. This duplication did
+    not impact the specific error traces captured, only the total metric.
+
+  * Notice gracefully handled errors in Sinatra
+
+    When show_exceptions was set to false in Sinatra, errors weren't caught
+    by New Relic's error collector. Now handled errors also have the chance
+    to get reported back.
+
+  * Ruby 2.0 compatibility fixes
+
+    Ruby 2.0 no longer finds protected methods by default, but will with a flag.
+    http://tenderlovemaking.com/2012/09/07/protected-methods-and-ruby-2-0.html
+
+    Thanks Ravil Bayramgalin and Charlie Somerville for the fixes.
+
+  * Auto-detect Trinidad as dispatcher
+
+    Code already existing for detecting Trinidad as a dispatcher, but was only
+    accessible via an ENV variable. This now auto-detects on startup. Thanks
+    Robert Rasmussen for catching that.
+
+  * Coercion of types in collector communication
+
+    Certain metrics can be recorded with a Ruby Rational type, which JSON
+    serializes as a string rather than a floating point value. We now treat
+    coerce each outgoing value, and log issues before sending the data.
+
+  * Developer mode fix for chart error
+
+    Added require to fix a NameError in developer mode for summary page. Thanks
+    to Ryan B. Harvey.
+
+  * Don't touch deprecated RAILS_ROOT if on Rails 3
+
+    Under some odd startup conditions, we would look for the RAILS_ROOT constant
+    after failing to find the ::Rails.root in a Rails 3 app, causing deprecation
+    warnings. Thanks for Adrian Irving-Beer for the fix.
+
 ## v3.5.5 ##
 
   * Add thread profiling support

data/Rakefile

@@ -5,7 +5,7 @@ require "#{File.dirname(__FILE__)}/lib/tasks/all.rb"
 
 task :default => :test
 
-task :test => [:gemspec, 'test:newrelic']
+task :test => ['test:newrelic']
 
 namespace :test do
   desc "Run all tests"
@@ -14,7 +14,7 @@ namespace :test do
   agent_home = File.expand_path(File.dirname(__FILE__))
 
   desc "Run functional test suite for newrelic"
-  task :multiverse, [:suite, :mode] => [:gemspec] do |t, args|
+  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}`
@@ -24,7 +24,7 @@ namespace :test do
   end
 
   desc "Test the multiverse testing framework by executing tests in test/multiverse/test. Get meta with it."
-  task 'multiverse:self', [:suite, :mode] => [:gemspec] do |t, args|
+  task 'multiverse:self', [:suite, :mode] => [] do |t, args|
     args.with_defaults(:suite => "", :mode => "")
     puts ("Testing the multiverse testing framework...")
     test_files = FileList['test/multiverse/test/*_test.rb']
@@ -43,20 +43,16 @@ namespace :test do
 
 end
 
-desc 'Generate gemspec [ build_number, stage ]'
-task :gemspec, [ :build_number, :stage ] do |t, args|
-  require 'erb'
-  version = NewRelic::VERSION::STRING.split('.')[0..2]
-  version << args.build_number.to_s if args.build_number
-  version << args.stage.to_s        if args.stage
-
-  version_string = version.join('.')
-  gem_version    = Gem::VERSION
-  date           = Time.now.strftime('%Y-%m-%d')
-  files          = `git ls-files`.split + ['newrelic_rpm.gemspec']
-
-  template = ERB.new(File.read('newrelic_rpm.gemspec.erb'))
-  File.open('newrelic_rpm.gemspec', 'w') do |gemspec|
-    gemspec.write(template.result(binding))
+desc 'Record build number and stage'
+task :record_build, [ :build_number, :stage ] do |t, args|
+  build_string = args.build_number
+  build_string << ".#{args.stage}" if args.stage
+
+  gitsha = File.exists?(".git") ? `git rev-parse HEAD` : "Unknown"
+  gitsha.chomp!
+
+  File.open("lib/new_relic/build.rb", "w") do |f|
+    f.write("# GITSHA: #{gitsha}\n")
+    f.write("module NewRelic; module VERSION; BUILD='#{build_string}'; end; end\n")
   end
 end

data/gem-public_cert.pem

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDODCCAiCgAwIBAgIBADANBgkqhkiG9w0BAQUFADBCMREwDwYDVQQDDAhzZWN1
+cml0eTEYMBYGCgmSJomT8ixkARkWCG5ld3JlbGljMRMwEQYKCZImiZPyLGQBGRYD
+Y29tMB4XDTEzMDIxMjE5MDcwN1oXDTE0MDIxMjE5MDcwN1owQjERMA8GA1UEAwwI
+c2VjdXJpdHkxGDAWBgoJkiaJk/IsZAEZFghuZXdyZWxpYzETMBEGCgmSJomT8ixk
+ARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJyYRvlk1XUo
+8JhWQcE/v6RmpK//JbeKvTKnmWVUKz5oTDSOg/LKEhzChpJJVSOMJHCxd4OoxkIN
+pjQF5U2af1m5ONeN1j4p4MujbwNeqxsJmixGLK/BZ9xTnbpYAa6xCRN1UfEcu3O9
+jjLHX3c63ghldwRBn/c2ZD6anMtDeq3C5MLiycFs9h7JXOa3cTTHLZknkYIoHMKN
+EFri5zlks50lbeaVvFRm4IMrYWRsEwzLZWaMOy68BVZe0UlBBKSMnzJfWkbdRRcm
+xqu7viu4hrrCGjUmdHKnl6tf7BY7wqQyKjj+O5DhayKmKRuQcEX8QVnsM+ayqiVU
+EtMiwNScUnsCAwEAAaM5MDcwCQYDVR0TBAIwADAdBgNVHQ4EFgQUOauaMsU0Elp6
+hiUisj4l63ZunSUwCwYDVR0PBAQDAgSwMA0GCSqGSIb3DQEBBQUAA4IBAQAuwrHh
+jOjIfAQoEbGakiwHTeImqmC1EjBEWb1+U+rC2OcsSQ3+2Q0mGq2u3lAphAeLa6i5
+WXb5OdQqZY2aI7NgMxRG98/+TcIlAT8tDR0e6/+QBlBuDXP3YI5Nuhp5U4LEvghr
+jEPaEo0AFPc1JpSO/zKmktU+e9VRAE+q55gLthP8fe0uZvtGUn0KgDbXJyOuGlHF
+J93N937OcyA2rD8gR1qkr3/0/we1dwLZnL6kN4p8nGzPgXZgOHsmTdYZ2ryYowtb
+Kc9+v+QxnbZYpu2IaPXOvm3T8G4O6qZvhnLh/Uien++Dj8eFBecTPoM8pVjK3ph5
+n/EwuZCcE6ghtCCM
+-----END CERTIFICATE-----

data/lib/new_relic/agent.rb

@@ -123,6 +123,9 @@ module NewRelic
     # drop it and not try to resend
     class UnrecoverableServerException < ServerConnectionException; end
 
+    # An unrecoverable client-side error that prevents the agent from continuing
+    class UnrecoverableAgentException < ServerConnectionException; end
+
     # Reserved for future use.  Meant to represent a problem on the server side.
     class ServerError < StandardError; end
 

data/lib/new_relic/agent/agent.rb

@@ -24,11 +24,15 @@ module NewRelic
         @launch_time = Time.now
 
         @metric_ids = {}
+        @events = NewRelic::Agent::EventListener.new
         @stats_engine = NewRelic::Agent::StatsEngine.new
         @transaction_sampler = NewRelic::Agent::TransactionSampler.new
         @sql_sampler = NewRelic::Agent::SqlSampler.new
         @thread_profiler = NewRelic::Agent::ThreadProfiler.new
+        @cross_process_monitor = NewRelic::Agent::CrossProcessMonitor.new(@events)
         @error_collector = NewRelic::Agent::ErrorCollector.new
+
+        @connect_state = :pending
         @connect_attempts = 0
 
         @last_harvest_time = Time.now
@@ -94,6 +98,10 @@ module NewRelic
         attr_reader :cross_process_encoding_bytes
         # service for communicating with collector
         attr_accessor :service
+        # Global events dispatcher. This will provides our primary mechanism
+        # for agent-wide events, such as finishing configuration, error notification
+        # and request before/after from Rack.
+        attr_reader :events
 
 
         # Returns the length of the unsent errors array, if it exists,
@@ -175,19 +183,21 @@ module NewRelic
           @forked = true
           Agent.config.apply_config(NewRelic::Agent::Configuration::ManualSource.new(options), 1)
 
-          # @connected gets false after we fail to connect or have an error
-          # connecting.  @connected has nil if we haven't finished trying to connect.
-          # or we didn't attempt a connection because this is the master process
-
           if channel_id = options[:report_to_channel]
             @service = NewRelic::Agent::PipeService.new(channel_id)
-            @connected_pid = $$
-            @metric_ids = {}
+            if connected?
+              @connected_pid = $$
+              @metric_ids = {}
+            else
+              ::NewRelic::Agent.logger.debug("Child process #{$$} not reporting to non-connected parent.")
+              @service.shutdown(Time.now)
+              disconnect
+            end
           end
 
           return if !Agent.config[:agent_enabled] ||
             !Agent.config[:monitor_mode] ||
-            @connected == false ||
+            disconnected? ||
             @worker_thread && @worker_thread.alive?
 
           ::NewRelic::Agent.logger.debug "Starting the worker thread in #{$$} after forking."
@@ -210,18 +220,11 @@ module NewRelic
           @started
         end
 
-        # Return nil if not yet connected, true if successfully started
-        # and false if we failed to start.
-        def connected?
-          @connected
-        end
-
         # Attempt a graceful shutdown of the agent, running the worker
         # loop if it exists and is running.
         #
         # Options:
-        # :force_send => (true/false) # force the agent to send data
-        # before shutting down
+        # :force_send  => (true/false) # force the agent to send data
         def shutdown(options={})
           run_loop_before_exit = Agent.config[:force_send]
           return if not started?
@@ -234,7 +237,6 @@ module NewRelic
 
           # if litespeed, then ignore all future SIGUSR1 - it's
           # litespeed trying to shut us down
-
           if Agent.config[:dispatcher] == :litespeed
             Signal.trap("SIGUSR1", "IGNORE")
             Signal.trap("SIGTERM", "IGNORE")
@@ -454,6 +456,14 @@ module NewRelic
                    :info, "Connecting workers after forking.")
           end
 
+          # Return true if we're using resque and it hasn't had a chance to (potentially)
+          # daemonize itself. This avoids hanging when there's a Thread started
+          # before Resque calls Process.daemon (Jira RUBY-857)
+          def defer_for_resque?
+            NewRelic::Agent.config[:dispatcher] == :resque &&
+              !NewRelic::Agent::PipeChannelManager.listener.started?
+          end
+
           # Sanity-check the agent configuration and start the agent,
           # setting up the worker thread and the exit handler to shut
           # down the agent
@@ -471,6 +481,12 @@ module NewRelic
         # Logs a bunch of data and starts the agent, if needed
         def start
           return if already_started? || disabled?
+
+          if defer_for_resque?
+            ::NewRelic::Agent.logger.debug "Deferring startup for Resque in case it daemonizes"
+            return
+          end
+
           @started = true
           @local_host = determine_host
           log_startup
@@ -518,7 +534,7 @@ module NewRelic
             ::NewRelic::Agent.logger.debug error.message
             reset_stats
             @metric_ids = {}
-            @connected = nil
+            @connect_state = :pending
             sleep 30
           end
 
@@ -577,7 +593,7 @@ module NewRelic
                 # just exit the thread.  If it returns nil
                 # that means it didn't try to connect because we're in the master.
                 connect(connection_options)
-                if @connected
+                if connected?
                   log_worker_loop_start
                   create_and_run_worker_loop
                   # never reaches here unless there is a problem or
@@ -610,60 +626,41 @@ module NewRelic
         # method - all of its methods are used in that context, so it
         # can be refactored at will. It should be fully tested
         module Connect
-          # the frequency with which we should try to connect to the
-          # server at the moment.
-          attr_accessor :connect_retry_period
           # number of attempts we've made to contact the server
           attr_accessor :connect_attempts
 
           # Disconnect just sets connected to false, which prevents
           # the agent from trying to connect again
           def disconnect
-            @connected = false
+            @connect_state = :disconnected
             true
           end
 
-          # We've tried to connect if @connected is not nil, or if we
-          # are forcing reconnection (i.e. in the case of an
-          # after_fork with long running processes)
-          def tried_to_connect?(options)
-            !(@connected.nil? || options[:force_reconnect])
+          def connected?
+            @connect_state == :connected
+          end
+
+          def disconnected?
+            @connect_state == :disconnected
           end
 
-          # We keep trying by default, but you can disable it with the
-          # :keep_retrying option set to false
-          def should_keep_retrying?(options)
-            @keep_retrying = (options[:keep_retrying].nil? || options[:keep_retrying])
+          # Don't connect if we're already connected, or if we tried to connect
+          # and were rejected with prejudice because of a license issue, unless
+          # we're forced to by force_reconnect.
+          def should_connect?(force=false)
+            force || (!connected? && !disconnected?)
           end
 
           # Retry period is a minute for each failed attempt that
           # we've made. This should probably do some sort of sane TCP
           # backoff to prevent hammering the server, but a minute for
           # each attempt seems to work reasonably well.
-          def get_retry_period
-            return 600 if self.connect_attempts > 6
-            connect_attempts * 60
-          end
-
-          def increment_retry_period! #:nodoc:
-            self.connect_retry_period=(get_retry_period)
+          def connect_retry_period
+            [600, connect_attempts * 60].min
           end
 
-          # We should only retry when there has not been a more
-          # serious condition that would prevent it. We increment the
-          # connect attempts and the retry period, to prevent constant
-          # connection attempts, and tell the user what we're doing by
-          # logging.
-          def should_retry?
-            if @keep_retrying
-              self.connect_attempts=(connect_attempts + 1)
-              increment_retry_period!
-              ::NewRelic::Agent.logger.warn "Will re-attempt in #{connect_retry_period} seconds"
-              true
-            else
-              disconnect
-              false
-            end
+          def note_connect_failure
+            self.connect_attempts += 1
           end
 
           # When we have a problem connecting to the server, we need
@@ -687,6 +684,12 @@ module NewRelic
             disconnect
           end
 
+          def handle_unrecoverable_agent_error(error)
+            ::NewRelic::Agent.logger.error(error.message)
+            disconnect
+            shutdown
+          end
+
           # Checks whether we should send environment info, and if so,
           # returns the snapshot from the local environment
           def environment_for_connect
@@ -744,24 +747,12 @@ module NewRelic
             Agent.config.apply_config(server_config, 1)
             log_connection!(config_data) if @service
 
-            @cross_process_id = Agent.config[:cross_process_id]
-            @cross_process_encoding_key = Agent.config[:encoding_key]
-            @cross_process_encoding_bytes = get_bytes(@cross_process_encoding_key) unless @cross_process_encoding_key.nil?
+            # If you're adding something else here to respond to the server-side config,
+            # use Agent.instance.events.subscribe(:finished_configuring) callback instead!
 
             @beacon_configuration = BeaconConfiguration.new
           end
 
-          # Ruby 1.8.6 doesn't support the bytes method on strings.
-          def get_bytes(value)
-            return [] if value.nil?
-
-            bytes = []
-            value.each_byte do |b|
-              bytes << b
-            end
-            bytes
-          end
-
           # Logs when we connect to the server, for debugging purposes
           # - makes sure we know if an agent has not connected
           def log_connection!(config_data)
@@ -813,11 +804,9 @@ module NewRelic
               @traces = transaction_traces
             end
           end
-          if errors && errors.respond_to?(:any?) && errors.any?
-            if @unsent_errors
-              @unsent_errors = @unsent_errors + errors
-            else
-              @unsent_errors = errors
+          if errors && errors.respond_to?(:each)
+            errors.each do |err|
+              @error_collector.add_to_error_queue(err)
             end
           end
         end
@@ -825,7 +814,7 @@ module NewRelic
         public :merge_data_from
 
         # Connect to the server and validate the license.  If successful,
-        # @connected has true when finished.  If not successful, you can
+        # connected? returns true when finished.  If not successful, you can
         # keep calling this.  Return false if we could not establish a
         # connection with the server and we should not retry, such as if
         # there's a bad license key.
@@ -840,25 +829,29 @@ module NewRelic
         # * <tt>force_reconnect => true</tt> if you want to establish a new connection
         #   to the server before running the worker loop.  This means you get a separate
         #   agent run and New Relic sees it as a separate instance (default is false).
-        def connect(options)
-          # Don't proceed if we already connected (@connected=true) or if we tried
-          # to connect and were rejected with prejudice because of a license issue
-          # (@connected=false), unless we're forced to by force_reconnect.
-          return if tried_to_connect?(options)
+        def connect(options={})
+          defaults = {
+            :keep_retrying => true,
+            :force_reconnect => false
+          }
+          opts = defaults.merge(options)
 
-          # wait a few seconds for the web server to boot, necessary in development
-          @connect_retry_period = should_keep_retrying?(options) ? 10 : 0
+          return unless should_connect?(opts[:force_reconnect])
 
-          sleep connect_retry_period
           ::NewRelic::Agent.logger.debug "Connecting Process to New Relic: #$0"
           query_server_for_configuration
           @connected_pid = $$
-          @connected = true
+          @connect_state = :connected
         rescue NewRelic::Agent::LicenseException => e
           handle_license_error(e)
+        rescue NewRelic::Agent::UnrecoverableAgentException => e
+          handle_unrecoverable_agent_error(e)
         rescue Timeout::Error, StandardError => e
           log_error(e)
-          if should_retry?
+          if opts[:keep_retrying]
+            note_connect_failure
+            ::NewRelic::Agent.logger.warn "Will re-attempt in #{connect_retry_period} seconds"
+            sleep connect_retry_period
             retry
           else
             disconnect
@@ -876,13 +869,6 @@ module NewRelic
           control.root
         end
 
-        # Checks whether this process is a Passenger or Unicorn
-        # spawning server - if so, we probably don't intend to report
-        # statistics from this process
-        def is_application_spawner?
-          $0 =~ /ApplicationSpawner|^unicorn\S* master/
-        end
-
         # calls the busy harvester and collects timeslice data to
         # send later
         def harvest_timeslice_data(time=Time.now)
@@ -1042,13 +1028,16 @@ module NewRelic
         def transmit_data(disconnecting=false)
           now = Time.now
           ::NewRelic::Agent.logger.debug "Sending data to New Relic Service"
-          harvest_and_send_errors
-          harvest_and_send_slowest_sample
-          harvest_and_send_slowest_sql
-          harvest_and_send_timeslice_data
-          harvest_and_send_thread_profile(disconnecting)
 
-          check_for_agent_commands
+          @service.session do # use http keep-alive
+            harvest_and_send_errors
+            harvest_and_send_slowest_sample
+            harvest_and_send_slowest_sql
+            harvest_and_send_timeslice_data
+            harvest_and_send_thread_profile(disconnecting)
+
+            check_for_agent_commands
+          end
         rescue => e
           retry_count ||= 0
           retry_count += 1
@@ -1071,7 +1060,7 @@ module NewRelic
         # If this process comes from a parent process, it will not
         # disconnect, so that the parent process can continue to send data
         def graceful_disconnect
-          if @connected
+          if connected?
             begin
               @service.request_timeout = 10
               transmit_data(true)