wd_newrelic_rpm 3.5.5 → 3.5.6

data/lib/new_relic/agent/instrumentation/rails3/action_controller.rb

@@ -149,7 +149,7 @@ DependencyDetection.defer do
 
       def render_with_newrelic(context, options)
         # This is needed for rails 3.2 compatibility
-        @details = extract_details(options) if respond_to? :extract_details
+        @details = extract_details(options) if respond_to? :extract_details, true
         identifier = determine_template(options) ? determine_template(options).identifier : nil
         str = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(identifier, options)}/Rendering"
         trace_execution_scoped str do

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

@@ -45,7 +45,14 @@ module NewRelic
           perform_action_with_newrelic_trace(:category => :sinatra,
                                              :name => txn_name,
                                              :params => @request.params) do
-            dispatch_without_newrelic
+            result = dispatch_without_newrelic
+
+            # Will only see an error raised if :show_exceptions is true, but
+            # will always see them in the env hash if they occur
+            had_error = env.has_key?('sinatra.error')
+            ::NewRelic::Agent.notice_error(env['sinatra.error']) if had_error
+
+            result
           end
         end
 

data/lib/new_relic/agent/new_relic_service.rb

@@ -29,7 +29,16 @@ module NewRelic
         Agent.config.register_callback(:'audit_log.enabled') do |enabled|
           @audit_logger.enabled = enabled
         end
-        
+        Agent.config.register_callback(:ssl) do |ssl|
+          if !ssl
+            ::NewRelic::Agent.logger.warn("Agent is configured not to use SSL when communicating with New Relic's servers")
+          elsif !Agent.config[:verify_certificate]
+            ::NewRelic::Agent.logger.warn("Agent is configured to use SSL but to skip certificate validation when communicating with New Relic's servers")
+          else
+            ::NewRelic::Agent.logger.debug("Agent is configured to use SSL")
+          end
+        end
+
         Agent.config.register_callback(:marshaller) do |marshaller|
           begin
             if marshaller == 'json'
@@ -106,6 +115,73 @@ module NewRelic
         [data, encoding]
       end
 
+      # One session with the service's endpoint.  In this case the session
+      # represents 1 tcp connection which may transmit multiple HTTP requests
+      # via keep-alive.
+      def session(&block)
+        raise ArgumentError, "#{self.class}#shared_connection must be passed a block" unless block_given?
+
+        http = create_http_connection
+
+        # Immediately open a TCP connection to the server and leave it open for
+        # multiple requests.
+        ::NewRelic::Agent.logger.debug("Opening TCP connection to #{http.address}:#{http.port}")
+        http.start
+        begin
+          @shared_tcp_connection = http
+          block.call
+        ensure
+          @shared_tcp_connection = nil
+          # Close the TCP socket
+          ::NewRelic::Agent.logger.debug("Closing TCP connection to #{http.address}:#{http.port}")
+          http.finish
+        end
+      end
+
+      # Return a Net::HTTP connection object to make a call to the collector.
+      # We'll reuse the same handle for cases where we're using keep-alive, or
+      # otherwise create a new one.
+      def http_connection
+        @shared_tcp_connection || create_http_connection
+      end
+
+      # Return the Net::HTTP with proxy configuration given the NewRelic::Control::Server object.
+      def create_http_connection
+        proxy_server = control.proxy_server
+        # Proxy returns regular HTTP if @proxy_host is nil (the default)
+        http_class = Net::HTTP::Proxy(proxy_server.name, proxy_server.port,
+                                      proxy_server.user, proxy_server.password)
+
+        http = http_class.new((@collector.ip || @collector.name), @collector.port)
+        if Agent.config[:ssl]
+          begin
+            # Jruby 1.6.8 requires a gem for full ssl support and will throw
+            # an error when use_ssl=(true) is called and jruby-openssl isn't
+            # installed
+            http.use_ssl = true
+            if Agent.config[:verify_certificate]
+              http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+              http.ca_file = cert_file_path
+            else
+              http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            end
+          rescue StandardError, LoadError
+            msg = "Agent is configured to use SSL, but SSL is not available in the environment. "
+            msg << "Either disable SSL in the agent configuration, or install SSL support."
+            raise UnrecoverableAgentException.new(msg)
+          end
+        end
+        ::NewRelic::Agent.logger.debug("Created net/http handle to #{http.address}:#{http.port}")
+        http
+      end
+
+
+      # The path to the certificate file used to verify the SSL
+      # connection if verify_peer is enabled
+      def cert_file_path
+        File.expand_path(File.join(control.newrelic_root, 'cert', 'cacert.pem'))
+      end
+
       private
 
       # A shorthand for NewRelic::Control.instance
@@ -183,31 +259,33 @@ module NewRelic
         request.content_type = "application/octet-stream"
         request.body = opts[:data]
 
-        ::NewRelic::Agent.logger.debug "Connect to #{opts[:collector]}#{opts[:uri]}"
-
         response = nil
-        http = control.http_connection(@collector)
+        http = http_connection
         http.read_timeout = nil
         begin
           NewRelic::TimerLib.timeout(@request_timeout) do
+            ::NewRelic::Agent.logger.debug "Sending request to #{opts[:collector]}#{opts[:uri]}"
             response = http.request(request)
           end
         rescue Timeout::Error
           ::NewRelic::Agent.logger.warn "Timed out trying to post data to New Relic (timeout = #{@request_timeout} seconds)" unless @request_timeout < 30
           raise
         end
-        if response.is_a? Net::HTTPUnauthorized
+        case response
+        when Net::HTTPSuccess
+          true # fall through
+        when Net::HTTPUnauthorized
           raise LicenseException, 'Invalid license key, please contact support@newrelic.com'
-        elsif response.is_a? Net::HTTPServiceUnavailable
+        when Net::HTTPServiceUnavailable
           raise ServerConnectionException, "Service unavailable (#{response.code}): #{response.message}"
-        elsif response.is_a? Net::HTTPGatewayTimeOut
+        when Net::HTTPGatewayTimeOut
           ::NewRelic::Agent.logger.warn("Timed out getting response: #{response.message}")
           raise Timeout::Error, response.message
-        elsif response.is_a? Net::HTTPRequestEntityTooLarge
+        when Net::HTTPRequestEntityTooLarge
           raise UnrecoverableServerException, '413 Request Entity Too Large'
-        elsif response.is_a? Net::HTTPUnsupportedMediaType
+        when Net::HTTPUnsupportedMediaType
           raise UnrecoverableServerException, '415 Unsupported Media Type'
-        elsif !(response.is_a? Net::HTTPSuccess)
+        else
           raise ServerConnectionException, "Unexpected response from server (#{response.code}): #{response.message}"
         end
         response
@@ -216,6 +294,8 @@ module NewRelic
         raise NewRelic::Agent::ServerConnectionException, "Recoverable error connecting to the server: #{e}"
       end
 
+
+
       # Decompresses the response from the server, if it is gzip
       # encoded, otherwise returns it verbatim
       def decompress_response(response)

data/lib/new_relic/agent/pipe_service.rb

@@ -39,6 +39,13 @@ module NewRelic
         write_to_pipe('EOF')
         NewRelic::Agent::PipeChannelManager.channels[@channel_id].close
       end
+
+      # Invokes the block it is passed.  This is used to implement HTTP
+      # keep-alive in the NewRelicService, and is a required interface for any
+      # Service class.
+      def session
+        yield
+      end
       
       private
 
@@ -52,6 +59,8 @@ module NewRelic
 
       def write_to_pipe(data)
         NewRelic::Agent::PipeChannelManager.channels[@channel_id].write(data)
+      rescue => e
+        NewRelic::Agent.logger.error("#{e.message}: Unable to send data to parent process, please see https://newrelic.com/docs/ruby/resque-instrumentation for more information.")
       end
     end
   end

data/lib/new_relic/agent/sql_sampler.rb

@@ -189,7 +189,7 @@ module NewRelic
         @params = {} #FIXME
         @sql_id = consistent_hash(normalized_query)
         set_primary slow_sql, path, uri
-        record_data_point slow_sql.duration
+        record_data_point(float(slow_sql.duration))
       end
 
       def set_primary(slow_sql, path, uri)
@@ -207,7 +207,7 @@ module NewRelic
           set_primary slow_sql, path, uri
         end
 
-        record_data_point slow_sql.duration
+        record_data_point(float(slow_sql.duration))
       end
 
       def prepare_to_send
@@ -223,8 +223,15 @@ module NewRelic
         Agent.config[:'slow_sql.explain_enabled']
       end
 
+      include NewRelic::Coerce
+
       def to_collector_array(encoder)
-        [ @path, @url, @sql_id, @sql, @database_metric_name, @call_count,
+        [ string(@path),
+          string(@url),
+          int(@sql_id),
+          string(@sql),
+          string(@database_metric_name),
+          int(@call_count),
           Helper.time_to_millis(@total_call_time),
           Helper.time_to_millis(@min_call_time),
           Helper.time_to_millis(@max_call_time),

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

@@ -100,6 +100,7 @@ module Agent
       def start_transaction(name = nil)
         Thread::current[:newrelic_scope_stack] ||= []
         self.scope_name = name if name
+        NewRelic::Agent.instance.events.notify(:start_transaction, name)
         GCProfiler.init
       end
 

data/lib/new_relic/agent/thread_profiler.rb

@@ -202,6 +202,8 @@ EOF
 
       THREAD_PROFILER_NODES = 20_000
 
+      include NewRelic::Coerce
+
       def to_collector_array(encoder)
         prune!(THREAD_PROFILER_NODES)
 
@@ -212,11 +214,15 @@ EOF
           "BACKGROUND" => @traces[:background].map{|t| t.to_array }
         }
 
-        [[@profile_id,
-          @start_time.to_f, @stop_time.to_f,
-          @poll_count,
-          encoder.encode(traces),
-          @sample_count, 0]]
+        [[
+          int(@profile_id),
+          float(@start_time),
+          float(@stop_time),
+          int(@poll_count),
+          string(encoder.encode(traces)),
+          int(@sample_count),
+          0
+        ]]
       end
 
       def now_in_millis
@@ -280,9 +286,16 @@ EOF
           [-runnable_count, depth] <=> [-y.runnable_count, y.depth]
         end
 
+        include NewRelic::Coerce
+
         def to_array
-          [[@file, @method, @line_no],
-            @runnable_count, 0,
+          [[
+              string(@file),
+              string(@method),
+              int(@line_no)
+            ],
+            int(@runnable_count),
+            0,
             @children.map {|c| c.to_array}]
         end
 

data/lib/new_relic/agent/worker_loop.rb

@@ -12,7 +12,7 @@ module NewRelic
         @should_run = true
         @next_invocation_time = Time.now
         @period = 60.0
-        @deadline = Time.now + opts[:duration] if opts[:duration]
+        @duration = opts[:duration] if opts[:duration]
         @limit = opts[:limit] if opts[:limit]
         @iterations = 0
       end
@@ -26,6 +26,7 @@ module NewRelic
       # call periods.  The caller is responsible for creating the thread
       # that runs this worker loop.  This will run the task immediately.
       def run(period=nil, &block)
+        @deadline = Time.now + @duration if @duration
         @period = period if period
         @next_invocation_time = (Time.now + @period)
         @task = block

data/lib/new_relic/coerce.rb

@@ -0,0 +1,37 @@
+module NewRelic
+  # We really don't want to send bad values to the collector, and it doesn't
+  # accept types like Rational that have occasionally slipped into our data.
+  #
+  # These methods are intended to safely coerce things into the form we want,
+  # to provide documentation of expected types on to_collector_array methods,
+  # and to log failures if totally invalid data gets into outgoing data
+  module Coerce
+    def int(value, context=nil)
+      Integer(value)
+    rescue => error
+      log_failure(value, Integer, context, error)
+      0
+    end
+
+    def float(value, context=nil)
+      Float(value)
+    rescue => error
+      log_failure(value, Float, context, error)
+      0.0
+    end
+
+    def string(value, context=nil)
+      return value if value.nil?
+      String(value)
+    rescue => error
+      log_failure(value.class, String, context, error)
+      ""
+    end
+
+    def log_failure(value, type, context, error)
+      msg = "Unable to convert '#{value}' to #{type}"
+      msg += " in context '#{context}'" if context
+      NewRelic::Agent.logger.warn(msg, error)
+    end
+  end
+end

data/lib/new_relic/commands/deployments.rb

@@ -54,7 +54,7 @@ class NewRelic::Command::Deployments < NewRelic::Command
       }.each do |k, v|
         create_params["deployment[#{k}]"] = v unless v.nil? || v == ''
       end
-      http = control.http_connection(control.api_server)
+      http = ::NewRelic::Agent::NewRelicService.new(nil, control.api_server).http_connection
 
       uri = "/deployments.xml"
 

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

@@ -10,14 +10,24 @@ module NewRelic
         def env
           @env ||= RAILS_ENV.dup
         end
+
+        # Rails can return an empty string from this method, causing
+        # the agent not to start even when it is properly in a rails 3
+        # application, so we test the value to make sure it actually
+        # has contents, and bail to the parent class if it is empty.
         def root
-          if defined?(RAILS_ROOT) && RAILS_ROOT.to_s != ''
-            RAILS_ROOT.to_s
+          root = rails_root.to_s
+          if !root.empty?
+            root
           else
             super
           end
         end
 
+        def rails_root
+          RAILS_ROOT if defined?(RAILS_ROOT)
+        end
+
         def rails_config
           if defined?(::Rails) && ::Rails.respond_to?(:configuration)
             ::Rails.configuration
@@ -46,8 +56,22 @@ module NewRelic
             ::NewRelic::Agent.logger.info("New Relic Agent not running.")
           else
             ::NewRelic::Agent.logger.info("Starting the New Relic Agent.")
-            install_developer_mode rails_config if Agent.config[:developer_mode]
+            install_developer_mode(rails_config) if Agent.config[:developer_mode]
             install_browser_monitoring(rails_config)
+            install_agent_hooks(rails_config)
+          end
+        end
+
+        def install_agent_hooks(config)
+          return if @agent_hooks_installed
+          @agent_hooks_installed = true
+          return if config.nil? || !config.respond_to?(:middleware)
+          begin
+            require 'new_relic/rack/agent_hooks'
+            config.middleware.use NewRelic::Rack::AgentHooks
+            ::NewRelic::Agent.logger.debug("Installed New Relic Agent Hooks middleware")
+          rescue => e
+            ::NewRelic::Agent.logger.warn("Error installing New Relic Agent Hooks middleware", e)
           end
         end
 
@@ -60,7 +84,7 @@ module NewRelic
             config.middleware.use NewRelic::Rack::BrowserMonitoring
             ::NewRelic::Agent.logger.debug("Installed New Relic Browser Monitoring middleware")
           rescue => e
-            ::NewRelic::Agent.logger.warn("Error installing New Relic Browser Monitoring middleware: #{e.inspect}")
+            ::NewRelic::Agent.logger.warn("Error installing New Relic Browser Monitoring middleware", e)
           end
         end
 
@@ -80,7 +104,7 @@ module NewRelic
                 ::NewRelic::Agent.logger.debug("To view performance information, go to http://localhost#{port}/newrelic")
               end
             rescue => e
-              ::NewRelic::Agent.logger.warn("Error installing New Relic Developer Mode: #{e.inspect}")
+              ::NewRelic::Agent.logger.warn("Error installing New Relic Developer Mode", e)
             end
           elsif rails_config
             ::NewRelic::Agent.logger.warn("Developer mode not available for Rails versions prior to 2.2")

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

@@ -14,17 +14,8 @@ module NewRelic
           @env ||= ::Rails.env.to_s
         end
 
-        # Rails can return an empty string from this method, causing
-        # the agent not to start even when it is properly in a rails 3
-        # application, so we test the value to make sure it actually
-        # has contents, and bail to the parent class if it is empty.
-        def root
-          value = ::Rails.root.to_s
-          if value.empty?
-            super
-          else
-            value
-          end
+        def rails_root
+          ::Rails.root.to_s
         end
 
         def init_config(options={})

data/lib/new_relic/control/instance_methods.rb

@@ -49,7 +49,10 @@ module NewRelic
 
         Agent.config.replace_or_add_config(Agent::Configuration::ManualSource.new(options), 1)
 
-        ::NewRelic::Agent.logger = NewRelic::Agent::AgentLogger.new(Agent.config, root, options.delete(:log))
+        # Be sure to only create once! RUBY-1020
+        if ::NewRelic::Agent.logger.is_startup_logger?
+          ::NewRelic::Agent.logger = NewRelic::Agent::AgentLogger.new(Agent.config, root, options.delete(:log))
+        end
 
         # Merge the stringified options into the config as overrides:
         environment_name = options.delete(:env) and self.env = environment_name
@@ -93,13 +96,19 @@ module NewRelic
       end
 
       def settings
-        NewRelic::Agent.config.reported_config
+        NewRelic::Agent.config.to_collector_hash
       end
 
       def dispatcher
         NewRelic::Agent.config[:dispatcher]
       end
 
+      # Delegates to the class method newrelic_root, implemented by
+      # each subclass
+      def newrelic_root
+        self.class.newrelic_root
+      end
+
       protected
 
       # Append framework specific environment information for uploading to
@@ -130,11 +139,6 @@ module NewRelic
         '.'
       end
 
-      # Delegates to the class method newrelic_root, implemented by
-      # each subclass
-      def newrelic_root
-        self.class.newrelic_root
-      end
     end
     include InstanceMethods
   end