ghazel-newrelic_rpm 3.4.0.2 → 3.5.4

data/lib/new_relic/control/server_methods.rb

@@ -18,29 +18,27 @@ module NewRelic
       # the server we should contact for api requests, like uploading
       # deployments and the like
       def api_server
-        api_host = self['api_host'] || 'rpm.newrelic.com'
-        @api_server ||=
-          NewRelic::Control::Server.new \
-        api_host,
-        (self['api_port'] || self['port'] || (use_ssl? ? 443 : 80)).to_i,
-        nil
+        @api_server ||= NewRelic::Control::Server.new(Agent.config[:api_host], Agent.config[:api_port], nil)
       end
       
       # a new instances of the proxy server - this passes through if
       # there is no proxy, otherwise it has proxy configuration
       # information pulled from the config file
       def proxy_server
-        @proxy_server ||=
-          NewRelic::Control::ProxyServer.new self['proxy_host'], self['proxy_port'], self['proxy_user'], self['proxy_pass']
+        @proxy_server ||= NewRelic::Control::ProxyServer.new(Agent.config[:proxy_host],
+                                                             Agent.config[:proxy_port],
+                                                             Agent.config[:proxy_user],
+                                                             Agent.config[:proxy_pass])
       end
       
       # turns a hostname into an ip address and returns a
       # NewRelic::Control::Server that contains the configuration info
       def server_from_host(hostname=nil)
-        host = hostname || self['host'] || 'collector.newrelic.com'
+        host = hostname || Agent.config[:host]
 
         # if the host is not an IP address, turn it into one
-        NewRelic::Control::Server.new host, (self['port'] || (use_ssl? ? 443 : 80)).to_i, convert_to_ip_address(host)
+        NewRelic::Control::Server.new(host, Agent.config[:port],
+                                      convert_to_ip_address(host))
       end
 
       # Check to see if we need to look up the IP address
@@ -50,7 +48,7 @@ module NewRelic
       def convert_to_ip_address(host)
         # here we leave it as a host name since the cert verification
         # needs it in host form
-        return host if verify_certificate?
+        return host if Agent.config[:ssl] && Agent.config[:verify_certificate]
         return nil if host.nil? || host.downcase == "localhost"
         ip = resolve_ip_address(host)
 
@@ -98,9 +96,9 @@ module NewRelic
                                       proxy_server.user, proxy_server.password)
         http = http_class.new(host.ip || host.name, host.port)
         log.debug("Http Connection opened to #{host.ip||host.name}:#{host.port}")
-        if use_ssl?
+        if Agent.config[:ssl]
           http.use_ssl = true
-          if verify_certificate?
+          if Agent.config[:verify_certificate]
             http.verify_mode = OpenSSL::SSL::VERIFY_PEER
             http.ca_file = cert_file_path
           else

data/lib/new_relic/delayed_job_injection.rb

@@ -15,7 +15,7 @@ DependencyDetection.defer do
   @name = :delayed_job_injection
   
   depends_on do
-    defined?(::Delayed) && defined?(::Delayed::Worker) && !NewRelic::Control.instance['disable_dj']
+    defined?(::Delayed) && defined?(::Delayed::Worker) && !NewRelic::Agent.config[:disable_dj]
   end
   
   executes do

data/lib/new_relic/helper.rb

@@ -17,5 +17,18 @@ module NewRelic
       end
     end
 
+    def instance_method_visibility(klass, method_name)
+      if klass.private_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+        :private
+      elsif klass.protected_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+        :protected
+      else
+        :public
+      end
+    end
+
+    def time_to_millis(time)
+      (time.to_f * 1000).round
+    end
   end
 end

data/lib/new_relic/language_support.rb

@@ -1,6 +1,6 @@
 module NewRelic::LanguageSupport
   extend self
-  
+
   module Control
     def self.included(base)
       # need to use syck rather than psych when possible
@@ -21,23 +21,8 @@ module NewRelic::LanguageSupport
       end
     end
   end
-  
-  module SynchronizedHash
-    def self.included(base)
-      # need to lock iteration of stats hash in 1.9.x
-      if NewRelic::LanguageSupport.using_version?('1.9') ||
-          NewRelic::LanguageSupport.using_engine?('jruby')
-        base.class_eval do
-          def each(*args, &block)
-            @lock.synchronize { super }
-          end
-        end
-      end
-    end
-  end
-  
+
   @@forkable = nil
-  
   def can_fork?
     # this is expensive to check, so we should only check once
     return @@forkable if @@forkable != nil
@@ -51,7 +36,7 @@ module NewRelic::LanguageSupport
 
     @@forkable
   end
-  
+
   def using_engine?(engine)
     if defined?(::RUBY_ENGINE)
       ::RUBY_ENGINE == engine
@@ -69,15 +54,27 @@ module NewRelic::LanguageSupport
 
   def with_disabled_gc
     if defined?(::GC) && ::GC.respond_to?(:disable)
-      ::GC.disable
-      val = yield
-      ::GC.enable
+      val = nil
+      begin
+        ::GC.disable
+        val = yield
+      ensure
+        ::GC.enable
+      end
       val
     else
       yield
     end
   end
-  
+
+  def with_cautious_gc
+    if broken_gc?
+      with_disabled_gc { yield }
+    else
+      yield
+    end
+  end
+
   def using_version?(version)
     numbers = version.split('.')
     numbers == ::RUBY_VERSION.split('.')[0, numbers.size]

data/lib/new_relic/local_environment.rb

@@ -14,7 +14,6 @@ module NewRelic
   #
   # NewRelic::LocalEnvironment should be accessed through NewRelic::Control#env (via the NewRelic::Control singleton).
   class LocalEnvironment
-    
     # mongrel, thin, webrick, or possibly nil
     attr_accessor :dispatcher
     # used to distinguish instances of a dispatcher from each other, may be nil
@@ -23,7 +22,7 @@ module NewRelic
     attr_accessor :framework
     # The number of cpus, if detected, or nil - many platforms do not
     # support this :(
-    attr_reader :processors 
+    attr_reader :processors
     alias environment dispatcher
 
     def initialize
@@ -404,7 +403,7 @@ module NewRelic
     end
 
     def check_for_passenger
-      if (defined?(::Passenger) && defined?(::Passenger::AbstractServer)) || defined?(::IN_PHUSION_PASSENGER)
+      if defined?(::PhusionPassenger)
         @dispatcher = :passenger
       end
     end

data/lib/new_relic/metric_data.rb

@@ -20,7 +20,7 @@ module NewRelic
     def original_spec
       @original_spec || @metric_spec
     end
-    
+
     # assigns a new metric spec, and retains the old metric spec as
     # @original_spec if it exists currently
     def metric_spec= new_spec
@@ -36,7 +36,7 @@ module NewRelic
     def to_json(*a)
        %Q[{"metric_spec":#{metric_id ? 'null' : metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}},"metric_id":#{metric_id ? metric_id : 'null'}}]
     end
-    
+
     def to_s
       if metric_spec
         "#{metric_spec.name}(#{metric_spec.scope}): #{stats}"
@@ -44,8 +44,16 @@ module NewRelic
         "#{metric_id}: #{stats}"
       end
     end
+
     def inspect
       "#<MetricData metric_spec:#{metric_spec.inspect}, stats:#{stats.inspect}, metric_id:#{metric_id.inspect}>"
     end
+
+    def to_collector_array(marshaller=nil)
+      stat_key = metric_id || { 'name' => metric_spec.name, 'scope' => metric_spec.scope }
+      [ stat_key,
+        [ stats.call_count, stats.total_call_time, stats.total_exclusive_time,
+          stats.min_call_time, stats.max_call_time, stats.sum_of_squares ] ]
+    end
   end
 end

data/lib/new_relic/metric_spec.rb

@@ -10,9 +10,13 @@ class NewRelic::MetricSpec
   # Need a "zero-arg" constructor so it can be instantiated from java (using
   # jruby) for sending responses to ruby agents from the java collector.
   #
-  def initialize(metric_name = '', metric_scope = '')
+  def initialize(metric_name = '', metric_scope = nil)
     self.name = (metric_name || '') && metric_name[LENGTH_RANGE]
-    self.scope = metric_scope && metric_scope[LENGTH_RANGE]
+    if metric_scope
+      self.scope = metric_scope && metric_scope[LENGTH_RANGE]
+    else
+      self.scope = ''
+    end
   end
   
   # truncates the name and scope to the MAX_LENGTH

data/lib/new_relic/noticed_error.rb

@@ -2,28 +2,43 @@
 class NewRelic::NoticedError
   extend NewRelic::CollectionHelper
   attr_accessor :path, :timestamp, :params, :exception_class, :message
+  attr_reader :exception_id
 
   def initialize(path, data, exception, timestamp = Time.now)
-    self.path = path
-    self.params = NewRelic::NoticedError.normalize_params(data)
+    @exception_id = exception.object_id
+    @path = path
+    @params = NewRelic::NoticedError.normalize_params(data)
 
-    self.exception_class = exception.is_a?(Exception) ? exception.class.name : 'Error'
+    @exception_class = exception.is_a?(Exception) ? exception.class.name : 'Error'
 
     if exception.respond_to?('original_exception')
-      self.message = exception.original_exception.message.to_s
+      @message = exception.original_exception.message.to_s
     else
-      self.message = (exception || '<no message>').to_s
+      @message = (exception || '<no message>').to_s
     end
 
     # clamp long messages to 4k so that we don't send a lot of
     # overhead across the wire
-    self.message = self.message[0..4095] if self.message.length > 4096
+    @message = @message[0..4095] if @message.length > 4096
     
     # obfuscate error message if necessary
-    if NewRelic::Control.instance.fetch('high_security', false)
-      self.message = NewRelic::Agent::Database.obfuscate_sql(self.message)
+    if NewRelic::Agent.config[:high_security]
+      @message = NewRelic::Agent::Database.obfuscate_sql(@message)
     end
     
-    self.timestamp = timestamp
+    @timestamp = timestamp
+  end
+
+  def ==(other)
+    if other.respond_to?(:exception_id)
+      @exception_id == other.exception_id
+    else
+      false
+    end
+  end
+
+  def to_collector_array(marshaller=nil)
+    [ (@timestamp.to_f * 1000).round, @path, @message, @exception_class,
+      @params ]
   end
 end

data/lib/new_relic/rack.rb

@@ -0,0 +1,4 @@
+module NewRelic
+  module Rack
+  end
+end

data/lib/new_relic/rack/browser_monitoring.rb

@@ -44,22 +44,40 @@ module NewRelic::Rack
         footer = NewRelic::Agent.browser_timing_footer
         header = NewRelic::Agent.browser_timing_header
 
-        if beginning_of_source.include?('X-UA-Compatible')
-          # put at end of header if UA-Compatible meta tag found
-          head_pos = beginning_of_source.index("</head>")
+        x_ua_compatible_found = beginning_of_source.include?('X-UA-Compatible')
+
+        head_pos = if x_ua_compatible_found
+          # put at end of header if X-UA-Compatible meta tag found
+          NewRelic::Agent.logger.debug "Detected X-UA-Compatible meta tag. Attempting to insert RUM header at end of head."
+          beginning_of_source.index("</head>")
         elsif head_open = beginning_of_source.index("<head")
+          NewRelic::Agent.logger.debug "Attempting to insert RUM header at beginning of head."
           # put at the beginning of the header
-          head_pos = beginning_of_source.index(">", head_open) + 1
+          beginning_of_source.index(">", head_open) + 1
         else
-          # put the header right above body start
-          head_pos = body_start
+          NewRelic::Agent.logger.debug "Failed to detect head tag. Attempting to insert RUM header at above body tag."
+          # otherwise put the header right above body start
+          body_start
         end
 
-        source = source[0..(head_pos-1)] + header + source[head_pos..(body_close-1)] + footer + source[body_close..-1]
-
-        headers['Content-Length'] = source.length.to_s if headers['Content-Length']
+        # check that head_pos is less than body close.  If it's not something
+        # is really weird and we should punt.
+        if head_pos && (head_pos < body_close)
+          # rebuild the source
+          source = source[0..(head_pos-1)] <<
+            header <<
+            source[head_pos..(body_close-1)] <<
+            footer <<
+            source[body_close..-1]
+        else
+          if head_pos
+            NewRelic::Agent.logger.debug "Skipping RUM instrumentation. Failed to detect head tags."
+          else
+            NewRelic::Agent.logger.debug "Skipping RUM instrumentation. Detected head is after detected body close."
+          end
+        end
       end
-
+      headers['Content-Length'] = source.length.to_s if headers['Content-Length']
       source
     end
   end

data/lib/new_relic/rack/developer_mode.rb

@@ -229,6 +229,9 @@ module NewRelic
         if params['d']
           @sql_segments.sort!{|a,b| b.duration <=> a.duration }
         end
+
+        sort_method = params['sort'] || :total_time
+        @profile_options = {:min_percent => 0.5, :sort_method => sort_method.to_sym}
         
         render(:show_sample)
       end

data/lib/new_relic/rack/error_collector.rb

@@ -0,0 +1,56 @@
+module NewRelic::Rack
+  class ErrorCollector
+    def initialize(app, options={})
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => exception
+      request = Rack::Request.new(env)
+      if !should_ignore_error?(exception, request)
+        NewRelic::Agent.instance.error_collector.notice_error(exception,
+                                                              :uri => request.path,
+                                                          :referer => request.referer,
+                                                   :request_params => request.params)
+      end
+      raise exception
+    end
+
+    def should_ignore_error?(error, request)
+      NewRelic::Agent.instance.error_collector.error_is_ignored?(error) ||
+        ignored_in_controller?(error, request)
+    end
+
+    def ignored_in_controller?(exception, request)
+      if request.env['action_dispatch.request.parameters']
+        ignore_actions = newrelic_ignore_for_controller(request.env['action_dispatch.request.parameters']['controller'])
+        action_name = request.env['action_dispatch.request.parameters']['action']
+
+        case ignore_actions
+        when nil; false
+        when Hash
+          only_actions = Array(ignore_actions[:only])
+          except_actions = Array(ignore_actions[:except])
+          only_actions.include?(action_name.to_sym) ||
+            (except_actions.any? &&
+             !except_actions.include?(action_name.to_sym))
+        else
+          true
+        end
+      end
+    end
+
+    def newrelic_ignore_for_controller(controller_name)
+      if controller_name
+        controller_constant_name = (controller_name + "_controller").camelize
+        if Object.const_defined?(controller_constant_name)
+          controller = controller_constant_name.constantize
+          controller.instance_variable_get(:@do_not_trace)
+        end
+      end
+    rescue NameError
+      nil
+    end
+  end
+end

data/lib/new_relic/transaction_sample.rb

@@ -1,3 +1,5 @@
+require 'base64'
+
 require 'new_relic/transaction_sample/segment'
 require 'new_relic/transaction_sample/summary_segment'
 require 'new_relic/transaction_sample/fake_segment'
@@ -51,15 +53,25 @@ module NewRelic
       @start_time - @@start_time.to_f
     end
 
-    # Used in the server only
-    def to_json(options = {}) #:nodoc:
-      map = {:sample_id => @sample_id,
-        :start_time => @start_time,
-        :root_segment => @root_segment}
-      if @params && !@params.empty?
-        map[:params] = @params
+    def to_json
+      JSON.dump(self.to_array)
+    end
+
+    def to_array
+      [ @start_time.to_f, @params[:request_params], @params[:custom_params],
+        @root_segment.to_array ]
+    end
+
+    def to_collector_array(marshaller)
+      trace_tree = if marshaller.respond_to?(:encode_compress)
+        marshaller.encode_compress(self.to_array)
+      else
+        self.to_array
       end
-      map.to_json
+
+      [ Helper.time_to_millis(@start_time), Helper.time_to_millis(duration),
+        @params[:path], @params[:uri], trace_tree, @guid, nil,
+        !!@force_persist ]
     end
 
     def start_time
@@ -134,10 +146,10 @@ module NewRelic
       regex = Regexp.new(regex)
 
       sample = TransactionSample.new(@start_time, sample_id)
-      
+
       sample.params = params.dup
       sample.params[:segment_count] = 0
-      
+
       delta = build_segment_with_omissions(sample, 0.0, @root_segment, sample.root_segment, regex)
       sample.root_segment.end_trace(@root_segment.exit_timestamp - delta)
       sample.profile = self.profile
@@ -160,7 +172,7 @@ module NewRelic
       sample.force_persist = self.force_persist if self.force_persist
 
       build_segment_for_transfer(sample, @root_segment, sample.root_segment, options)
-      
+
       sample.root_segment.end_trace(@root_segment.exit_timestamp)
       sample
     end
@@ -171,8 +183,6 @@ module NewRelic
 
   private
 
-
-
     HEX_DIGITS = (0..15).map{|i| i.to_s(16)}
     # generate a random 64 bit uuid
     def generate_guid