newrelic_rpm 3.8.1.221 → 3.9.0.229

data/lib/new_relic/agent/cross_app_tracing.rb

@@ -33,8 +33,8 @@ module NewRelic
       # See the documentation for +start_trace+ for an explanation of what
       # +request+ should look like.
       #
-      def trace_http_request( request )
-        return yield unless NewRelic::Agent.is_execution_traced?
+      def trace_http_request(request) #THREAD_LOCAL_ACCESS
+        return yield unless NewRelic::Agent.tl_is_execution_traced?
 
         begin
           t0, segment = start_trace( request )
@@ -63,11 +63,11 @@ module NewRelic
       # This method MUST return a pair. The first item always returns the
       # starting time of the trace, even if an error occurs. The second item is
       # the transaction segment if it was sucessfully pushed.
-      def start_trace(request)
+      def start_trace(request) #THREAD_LOCAL_ACCESS
         t0 = Time.now
 
         inject_request_headers(request) if cross_app_enabled?
-        segment = NewRelic::Agent::TracedMethodStack.push_frame(:http_request, t0)
+        segment = NewRelic::Agent::TracedMethodStack.tl_push_frame(:http_request, t0)
 
         return t0, segment
       rescue => err
@@ -87,7 +87,7 @@ module NewRelic
       # * [](key) - Reads response headers.
       # * to_hash - Converts response headers to a Hash
       #
-      def finish_trace( t0, segment, request, response )
+      def finish_trace(t0, segment, request, response) #THREAD_LOCAL_ACCESS
         t1 = Time.now
         duration = t1.to_f - t0.to_f
 
@@ -95,11 +95,11 @@ module NewRelic
           if request
             # Figure out which metrics we need to report based on the request and response
             # The last (most-specific) one is scoped.
-            metrics = metrics_for( request, response )
+            metrics = metrics_for(request, response)
             scoped_metric = metrics.pop
 
-            stats_engine.record_metrics(metrics, duration)
-            stats_engine.record_metrics(scoped_metric, duration, :scoped => true)
+            stats_engine.tl_record_scoped_and_unscoped_metrics(
+              scoped_metric, metrics, duration)
 
             # If we don't have segment, something failed during start_trace so
             # the current segment isn't the HTTP call it should have been.
@@ -111,7 +111,7 @@ module NewRelic
         ensure
           # If we have a segment, always pop the traced method stack to avoid
           # an inconsistent state, which prevents tracing of whole transaction.
-          NewRelic::Agent::TracedMethodStack.pop_frame( segment, scoped_metric, t1 ) if segment
+          NewRelic::Agent::TracedMethodStack.tl_pop_frame(segment, scoped_metric, t1) if segment
         end
       rescue NewRelic::Agent::CrossAppTracing::Error => err
         NewRelic::Agent.logger.debug "while cross app tracing", err
@@ -150,12 +150,13 @@ module NewRelic
       end
 
       # Inject the X-Process header into the outgoing +request+.
-      def inject_request_headers( request )
+      def inject_request_headers(request) #THREAD_LOCAL_ACCESS
         cross_app_id = NewRelic::Agent.config[:cross_process_id] or
           raise NewRelic::Agent::CrossAppTracing::Error, "no cross app ID configured"
 
-        NewRelic::Agent::TransactionState.get.is_cross_app_caller = true
-        txn_guid = NewRelic::Agent::TransactionState.get.request_guid
+        state = NewRelic::Agent::TransactionState.tl_get
+        state.is_cross_app_caller = true
+        txn_guid = state.request_guid
         txn_data = NewRelic::JSONWrapper.dump([ txn_guid, false ])
 
         request[ NR_ID_HEADER ]  = obfuscator.obfuscate( cross_app_id )

data/lib/new_relic/agent/error_collector.rb

@@ -28,7 +28,6 @@ module NewRelic
 
         # lookup of exception class names to ignore.  Hash for fast access
         @ignore = {}
-        @capture_source = Agent.config[:'error_collector.capture_source']
 
         initialize_ignored_errors(Agent.config[:'error_collector.ignore_errors'])
         @lock = Mutex.new
@@ -52,6 +51,10 @@ module NewRelic
         Agent.config[:'error_collector.enabled']
       end
 
+      def disabled?
+        !enabled?
+      end
+
       # Returns the error filter proc that is used to check if an
       # error should be reported. When given a block, resets the
       # filter to the provided block.  The define_method() is used to
@@ -66,6 +69,12 @@ module NewRelic
         end
       end
 
+      # Only used from testing scenarios since can't tell difference between
+      # having a nil filter passed and no block for retrieval on main method.
+      def clear_ignore_error_filter
+        @ignore_filter = nil
+      end
+
       # errors is an array of Exception Class Names
       #
       def ignore(errors)
@@ -94,55 +103,49 @@ module NewRelic
         # an error is ignored if it is nil or if it is filtered
         def error_is_ignored?(error)
           error && filtered_error?(error)
+        rescue => e
+          NewRelic::Agent.logger.error("Error '#{error}' will NOT be ignored. Exception '#{e}' while determining whether to ignore or not.", e)
+          false
         end
 
-        def seen?(exception)
-          error_ids = TransactionState.get.transaction_noticed_error_ids
+        def seen?(txn, exception)
+          error_ids = txn.nil? ? [] : txn.noticed_error_ids
           error_ids.include?(exception.object_id)
         end
 
-        def tag_as_seen(exception)
-          txn = Transaction.current
+        def tag_as_seen(txn, exception)
           txn.noticed_error_ids << exception.object_id if txn
         end
 
-        def blamed_metric_name(options)
+        def blamed_metric_name(txn, options)
           if options[:metric] && options[:metric] != ::NewRelic::Agent::UNKNOWN_METRIC
             "Errors/#{options[:metric]}"
           else
-            if txn = TransactionState.get.most_recent_transaction
-              "Errors/#{txn.name}"
-            end
+            "Errors/#{txn.best_name}" if txn
           end
         end
 
         # Increments a statistic that tracks total error rate
         # Be sure not to double-count same exception. This clears per harvest.
-        def increment_error_count!(exception, options={})
-          return if seen?(exception)
-          tag_as_seen(exception)
+        def increment_error_count!(exception, options={}) #THREAD_LOCAL_ACCESS
+          state = ::NewRelic::Agent::TransactionState.tl_get
+          txn = state.current_transaction
+
+          return if seen?(txn, exception)
+          tag_as_seen(txn, exception)
 
           metric_names = ["Errors/all"]
-          blamed_metric = blamed_metric_name(options)
+          blamed_metric = blamed_metric_name(txn, options)
           metric_names << blamed_metric if blamed_metric
 
           stats_engine = NewRelic::Agent.agent.stats_engine
-          stats_engine.record_metrics(metric_names) do |stats|
+          stats_engine.record_unscoped_metrics(state, metric_names) do |stats|
             stats.increment_count
           end
         end
 
-        # whether we should return early from the notice_error process
-        # - based on whether the error is ignored or the error
-        # collector is disabled
-        def should_exit_notice_error?(exception)
-          if enabled?
-            if !error_is_ignored?(exception)
-              return exception.nil? # exit early if the exception is nil
-            end
-          end
-          # disabled or an ignored error, per above
-          true
+        def skip_notice_error?(exception)
+          disabled? || error_is_ignored?(exception) || exception.nil?
         end
 
         # acts just like Hash#fetch, but deletes the key from the hash
@@ -204,12 +207,6 @@ module NewRelic
           object.send(method) if object.respond_to?(method)
         end
 
-        # extracts source from the exception, if the exception supports
-        # that method
-        def extract_source(exception)
-          sense_method(exception, 'source_extract') if @capture_source
-        end
-
         # extracts a stack trace from the exception for debugging purposes
         def extract_stack_trace(exception)
           actual_exception = sense_method(exception, 'original_exception') || exception
@@ -223,7 +220,6 @@ module NewRelic
           {
             :file_name => sense_method(exception, 'file_name'),
             :line_number => sense_method(exception, 'line_number'),
-            :source => extract_source(exception),
             :stack_trace => extract_stack_trace(exception)
           }
         end
@@ -231,7 +227,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.reject{|err| err.exception_class_constant < NewRelic::Agent::InternalAgentError}.length >= MAX_ERROR_QUEUE_LENGTH)
+          over_limit = (@errors.reject{|err| err.is_internal}.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
@@ -262,7 +258,7 @@ module NewRelic
       # If anything is left over, it's added to custom params
       # If exception is nil, the error count is bumped and no traced error is recorded
       def notice_error(exception, options={})
-        return if should_exit_notice_error?(exception)
+        return if skip_notice_error?(exception)
         increment_error_count!(exception, options)
         NewRelic::Agent.instance.events.notify(:notice_error, exception, options)
         action_path       = fetch_from_options(options, :metric, "")
@@ -290,7 +286,7 @@ module NewRelic
 
         @lock.synchronize do
           # Already seen this class once? Bail!
-          return if @errors.any? { |err| err.exception_class_constant == exception.class }
+          return if @errors.any? { |err| err.exception_class_name == exception.class.name }
 
           trace = exception.backtrace || caller.dup
           noticed_error = NewRelic::NoticedError.new("NewRelic/AgentError",

data/lib/new_relic/agent/harvester.rb

@@ -23,7 +23,7 @@ module NewRelic
       end
 
       def on_transaction(*_)
-        return unless restart_in_children_enabled? && needs_restart?
+        return unless restart_in_children_enabled? && needs_restart? && harvest_thread_enabled?
 
         needs_thread_start = false
         @lock.synchronize do
@@ -48,6 +48,10 @@ module NewRelic
         NewRelic::Agent.config[:restart_thread_in_children]
       end
 
+      def harvest_thread_enabled?
+        !NewRelic::Agent.config[:disable_harvest_thread]
+      end
+
       def restart_harvest_thread
         # Daemonize reports thread as still alive when it isn't... whack!
         NewRelic::Agent.instance.instance_variable_set(:@worker_thread, nil)

data/lib/new_relic/agent/hostname.rb

@@ -0,0 +1,17 @@
+# 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 Hostname
+      def self.get
+        if (dyno_name = ENV['DYNO']) && ::NewRelic::Agent.config[:use_heroku_dyno_names]
+          dyno_name
+        else
+          Socket.gethostname
+        end
+      end
+    end
+  end
+end

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

@@ -32,7 +32,7 @@ module NewRelic
         end
 
         def uri
-          @uri ||= URI( @curlobj.url )
+          @uri ||= NewRelic::Agent::HTTPClients::URIUtil.parse_url(@curlobj.url)
         end
       end
 

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

@@ -40,7 +40,7 @@ module NewRelic
           @request = request
           @uri = case request.url
             when ::URI then request.url
-            else ::URI.parse(request.url.to_s)
+            else NewRelic::Agent::HTTPClients::URIUtil.parse_url(request.url)
             end
         end
 

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

@@ -23,6 +23,19 @@ module NewRelic
           filtered.to_s
         end
 
+        # There are valid URI strings that some HTTP client libraries will
+        # accept that the stdlib URI module doesn't handle. If we find that
+        # Addressable is around, use that to normalize out our URL's.
+        def self.parse_url(url)
+          if defined?(::Addressable::URI)
+            address = ::Addressable::URI.parse(url)
+            address.normalize!
+            URI.parse(address.to_s)
+          else
+            URI.parse(url)
+          end
+        end
+
       end
     end
   end

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

@@ -7,43 +7,33 @@ module NewRelic
   module Agent
     module Instrumentation
       class ActionControllerSubscriber < EventedSubscriber
-        def initialize
-          super
-          NewRelic::Agent.instance.events.subscribe(:before_call) do |env|
-
-            request = begin
-                        require 'rack'
-                        ::Rack::Request.new(env)
-                      rescue => e
-                        Agent.logger.debug("Error creating Rack::Request object: #{e}")
-                        nil
-                      end
-            TransactionState.request = request
-          end
-        end
 
-        def start(name, id, payload)
-          request = TransactionState.get.request
+        def start(name, id, payload) #THREAD_LOCAL_ACCESS
+          state = TransactionState.tl_get
+          request = state.request
           event = ControllerEvent.new(name, Time.now, nil, id, payload, request)
           push_event(event)
 
-          if NewRelic::Agent.is_execution_traced? && !event.ignored?
-            start_transaction(event)
+          if state.is_execution_traced? && !event.ignored?
+            start_transaction(state, event)
           else
             # if this transaction is ignored, make sure child
             # transaction are also ignored
+            state.current_transaction.ignore! if state.current_transaction
             NewRelic::Agent.instance.push_trace_execution_flag(false)
           end
         rescue => e
           log_notification_error(e, name, 'start')
         end
 
-        def finish(name, id, payload)
+        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
           event = pop_event(id)
           event.payload.merge!(payload)
 
-          if NewRelic::Agent.is_execution_traced? && !event.ignored?
-            stop_transaction(event)
+          state = TransactionState.tl_get
+
+          if state.is_execution_traced? && !event.ignored?
+            stop_transaction(state, event)
           else
             Agent.instance.pop_trace_execution_flag
           end
@@ -51,19 +41,19 @@ module NewRelic
           log_notification_error(e, name, 'finish')
         end
 
-        def start_transaction(event)
-          Transaction.start(:controller,
+        def start_transaction(state, event)
+          Transaction.start(state, :controller,
                             :request          => event.request,
                             :filtered_params  => filter(event.payload[:params]),
                             :apdex_start_time => event.queue_start,
                             :transaction_name => event.metric_name)
         end
 
-        def stop_transaction(event)
-          Transaction.stop(Time.now,
-                           :exception_encountered => event.exception_encountered?,
-                           :ignore_apdex          => event.apdex_ignored?,
-                           :ignore_enduser        => event.enduser_ignored?)
+        def stop_transaction(state, event)
+          txn = state.current_transaction
+          txn.ignore_apdex!   if event.apdex_ignored?
+          txn.ignore_enduser! if event.enduser_ignored?
+          Transaction.stop(state)
         end
 
         def filter(params)
@@ -113,10 +103,6 @@ module NewRelic
           _is_filtered?('ignore_enduser')
         end
 
-        def exception_encountered?
-          payload[:exception]
-        end
-
         # FIXME: shamelessly ripped from ControllerInstrumentation
         def _is_filtered?(key)
           if @controller_class.respond_to? :newrelic_read_attr

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

@@ -9,38 +9,38 @@ module NewRelic
   module Agent
     module Instrumentation
       class ActionViewSubscriber < EventedSubscriber
-        def start(name, id, payload)
+        def start(name, id, payload) #THREAD_LOCAL_ACCESS
           event = RenderEvent.new(name, Time.now, nil, id, payload)
           push_event(event)
 
-          if NewRelic::Agent.is_execution_traced? && event.recordable?
-            event.frame = NewRelic::Agent::TracedMethodStack.push_frame(:action_view, event.time)
+          state = NewRelic::Agent::TransactionState.tl_get
+
+          if state.is_execution_traced? && event.recordable?
+            stack = state.traced_method_stack
+            event.frame = stack.push_frame(state, :action_view, event.time)
           end
         rescue => e
           log_notification_error(e, name, 'start')
         end
 
-        def finish(name, id, payload)
+        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
           event = pop_event(id)
 
-          if NewRelic::Agent.is_execution_traced? && event.recordable?
-            frame = NewRelic::Agent::TracedMethodStack.pop_frame(event.frame, event.metric_name, event.end)
+          state = NewRelic::Agent::TransactionState.tl_get
+
+          if state.is_execution_traced? && event.recordable?
+            stack = state.traced_method_stack
+            frame = stack.pop_frame(state, event.frame, event.metric_name, event.end)
             record_metrics(event, frame)
           end
         rescue => e
           log_notification_error(e, name, 'finish')
         end
 
-        def record_metrics(event, frame)
+        def record_metrics(event, frame) #THREAD_LOCAL_ACCESS
           exclusive = event.duration - frame.children_time
-          metric_specs = [
-            NewRelic::MetricSpec.new(event.metric_name),
-            NewRelic::MetricSpec.new(event.metric_name, StatsEngine::MetricStats::SCOPE_PLACEHOLDER)
-          ]
-          NewRelic::Agent.instance.stats_engine \
-            .record_metrics_internal(metric_specs,
-                                     event.duration,
-                                     exclusive)
+          NewRelic::Agent.instance.stats_engine.tl_record_scoped_and_unscoped_metrics(
+            event.metric_name, nil, event.duration, exclusive)
         end
 
         class RenderEvent < Event