newrelic_rpm 3.9.0.229 → 3.9.1.236

data/lib/new_relic/agent/traced_method_stack.rb

@@ -23,18 +23,6 @@ module NewRelic
         @stack = []
       end
 
-      def self.tl_push_frame(tag, time = Time.now.to_f)
-        state = NewRelic::Agent::TransactionState.tl_get
-        stack = state.traced_method_stack
-        stack.push_frame(state, tag, time)
-      end
-
-      def self.tl_pop_frame(expected_frame, name, time, deduct_call_time_from_parent=true)
-        state = NewRelic::Agent::TransactionState.tl_get
-        stack = state.traced_method_stack
-        stack.pop_frame(state, expected_frame, name, time, deduct_call_time_from_parent)
-      end
-
       # Pushes a frame onto the transaction stack - this generates a
       # TransactionSample::Segment at the end of transaction execution.
       #

data/lib/new_relic/agent/transaction.rb

@@ -126,11 +126,21 @@ module NewRelic
         end
 
         txn
+      rescue => e
+        NewRelic::Agent.logger.error("Exception during Transaction.start", e)
+        nil
       end
 
+      FAILED_TO_STOP_MESSAGE = "Failed during Transaction.stop because there is no current transaction"
+
       def self.stop(state, end_time=Time.now)
         txn = state.current_transaction
 
+        if txn.nil?
+          NewRelic::Agent.logger.error(FAILED_TO_STOP_MESSAGE)
+          return
+        end
+
         if txn.frame_stack.empty?
           txn.stop(state, end_time)
           state.reset
@@ -166,6 +176,9 @@ module NewRelic
         end
 
         :transaction_stopped
+      rescue => e
+        NewRelic::Agent.logger.error("Exception during Transaction.stop", e)
+        nil
       end
 
       def self.nested_transaction_name(name)
@@ -188,7 +201,7 @@ module NewRelic
         end
       end
 
-      attr_reader :frame_stack
+      attr_reader :frame_stack, :cat_path_hashes
 
       def initialize(category, options)
         @frame_stack = []
@@ -209,6 +222,7 @@ module NewRelic
         @exceptions = {}
         @metrics = TransactionMetrics.new
         @guid = generate_guid
+        @cat_path_hashes = nil
 
         @ignore_this_transaction = false
         @ignore_apdex = false
@@ -416,23 +430,85 @@ module NewRelic
       # This event is fired when the transaction is fully completed. The metric
       # values and sampler can't be successfully modified from this event.
       def send_transaction_finished_event(state, start_time, end_time)
+        duration = end_time.to_f - start_time.to_f
         payload = {
           :name             => @frozen_name,
           :start_timestamp  => start_time.to_f,
-          :duration         => end_time.to_f - start_time.to_f,
+          :duration         => duration,
           :metrics          => @metrics,
           :custom_params    => custom_parameters
         }
-        append_guid_to(state, payload)
+        append_cat_info(state, duration, payload)
+        append_apdex_perf_zone(duration, payload)
         append_referring_transaction_guid_to(state, payload)
 
         agent.events.notify(:transaction_finished, payload)
       end
 
-      def append_guid_to(state, payload)
-        guid = state.request_guid_for_event
-        if guid
-          payload[:guid] = guid
+      def include_guid?(state, duration)
+        state.is_cross_app? ||
+        (state.request_token && duration > apdex_t)
+      end
+
+      def cat_trip_id(state)
+        NewRelic::Agent.instance.cross_app_monitor.client_referring_transaction_trip_id(state) || guid
+      end
+
+      def cat_path_hash(state)
+        referring_path_hash = cat_referring_path_hash(state) || '0'
+        seed = referring_path_hash.to_i(16)
+        result = NewRelic::Agent.instance.cross_app_monitor.path_hash(best_name, seed)
+        record_cat_path_hash(result)
+        result
+      end
+
+      def record_cat_path_hash(hash)
+        @cat_path_hashes ||= []
+        if @cat_path_hashes.size < 10 && !@cat_path_hashes.include?(hash)
+          @cat_path_hashes << hash
+        end
+      end
+
+      def cat_referring_path_hash(state)
+        NewRelic::Agent.instance.cross_app_monitor.client_referring_transaction_path_hash(state)
+      end
+
+      APDEX_S = 'S'.freeze
+      APDEX_T = 'T'.freeze
+      APDEX_F = 'F'.freeze
+
+      def append_apdex_perf_zone(duration, payload)
+        return unless recording_web_transaction?
+
+        bucket = apdex_bucket(duration)
+        bucket_str = case bucket
+        when :apdex_s then APDEX_S
+        when :apdex_t then APDEX_T
+        when :apdex_f then APDEX_F
+        else nil
+        end
+        payload[:apdex_perf_zone] = bucket_str if bucket_str
+      end
+
+      def append_cat_info(state, duration, payload)
+        return unless include_guid?(state, duration)
+        payload[:guid] = guid
+
+        return unless state.is_cross_app?
+        trip_id             = cat_trip_id(state)
+        path_hash           = cat_path_hash(state)
+        referring_path_hash = cat_referring_path_hash(state)
+
+        payload[:cat_trip_id]             = trip_id             if trip_id
+        payload[:cat_referring_path_hash] = referring_path_hash if referring_path_hash
+
+        if path_hash
+          payload[:cat_path_hash] = path_hash
+
+          alternate_path_hashes = cat_path_hashes - [path_hash]
+          unless alternate_path_hashes.empty?
+            payload[:cat_alternate_path_hashes] = alternate_path_hashes
+          end
         end
       end
 
@@ -505,16 +581,23 @@ module NewRelic
 
       APDEX_METRIC = 'Apdex'.freeze
 
+      def had_error?
+        !notable_exceptions.empty?
+      end
+
+      def apdex_bucket(duration)
+        self.class.apdex_bucket(duration, had_error?, apdex_t)
+      end
+
       def record_apdex(state, end_time=Time.now)
         return unless recording_web_transaction? && state.is_execution_traced?
 
         freeze_name_and_execute_if_not_ignored do
           action_duration = end_time - start_time
           total_duration  = end_time - apdex_start
-          is_error = !notable_exceptions.empty?
 
-          apdex_bucket_global = self.class.apdex_bucket(total_duration,  is_error, apdex_t)
-          apdex_bucket_txn    = self.class.apdex_bucket(action_duration, is_error, apdex_t)
+          apdex_bucket_global = apdex_bucket(total_duration)
+          apdex_bucket_txn    = apdex_bucket(action_duration)
 
           @metrics.record_unscoped(APDEX_METRIC, apdex_bucket_global, apdex_t)
           txn_apdex_metric = @frozen_name.gsub(/^[^\/]+\//, 'Apdex/')
@@ -559,6 +642,11 @@ module NewRelic
       end
 
       def add_custom_parameters(p)
+        if NewRelic::Agent.config[:high_security]
+          NewRelic::Agent.logger.debug("Unable to add custom attributes #{p.keys.inspect} while in high security mode.")
+          return
+        end
+
         custom_parameters.merge!(p)
       end
 

data/lib/new_relic/agent/transaction_sampler.rb

@@ -126,10 +126,17 @@ module NewRelic
         last_builder.set_transaction_name(txn.best_name)
         last_builder.finish_trace(time.to_f, custom_parameters_from_transaction(txn))
 
+        last_sample = last_builder.sample
+        last_sample.guid = txn.guid
+        last_sample.set_custom_param(:gc_time, gc_time) if gc_time
+
+        if state.is_cross_app?
+          last_sample.set_custom_param(:'nr.trip_id', txn.cat_trip_id(state))
+          last_sample.set_custom_param(:'nr.path_hash', txn.cat_path_hash(state))
+        end
+
         @samples_lock.synchronize do
-          @last_sample = last_builder.sample
-          @last_sample.guid = txn.guid
-          @last_sample.set_custom_param(:gc_time, gc_time) if gc_time
+          @last_sample = last_sample
           store_sample(@last_sample)
           @last_sample
         end

data/lib/new_relic/agent/transaction_state.rb

@@ -84,9 +84,8 @@ module NewRelic
         referring_transaction_info != nil
       end
 
-      def request_guid_for_event
-        return nil unless is_cross_app_callee? || is_cross_app_caller? || include_guid?
-        request_guid
+      def is_cross_app?
+        is_cross_app_caller? || is_cross_app_callee?
       end
 
       # Request data
@@ -98,15 +97,6 @@ module NewRelic
         current_transaction.guid
       end
 
-      def request_guid_to_include
-        return "" unless include_guid?
-        request_guid
-      end
-
-      def include_guid?
-        request_token && timings.app_time_in_seconds > current_transaction.apdex_t
-      end
-
       # Current transaction stack and sample building
       attr_reader   :current_transaction
       attr_accessor :transaction_sample_builder

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

@@ -8,9 +8,6 @@ module NewRelic
     module Frameworks
       # Contains basic control logic for Sinatra
       class Sinatra < NewRelic::Control::Frameworks::Ruby
-        def init_config(options={})
-          super
-        end
       end
     end
   end

data/lib/new_relic/control/instance_methods.rb

@@ -85,6 +85,11 @@ module NewRelic
 
         config_file_path = @config_file_override || Agent.config[:config_path]
         Agent.config.replace_or_add_config(Agent::Configuration::YamlSource.new(config_file_path, env))
+
+        if Agent.config[:high_security]
+          Agent.logger.info("Installing high security configuration based on local configuration")
+          Agent.config.replace_or_add_config(Agent::Configuration::HighSecuritySource.new(Agent.config))
+        end
       end
 
       # Install the real agent into the Agent module, and issue the start command.

data/lib/new_relic/json_wrapper.rb

@@ -33,6 +33,11 @@ module NewRelic
     end
 
     def self.normalize_string(s)
+      # Early return if called on 1.8.x. In normal circumstances 1.8.x
+      # shouldn't call this--it does nothing for Ruby-marshalled formats-- but
+      # we use it in multiverse to make comparing data more consistent.
+      return s unless supports_normalization?
+
       encoding = s.encoding
       if (encoding == Encoding::UTF_8 || encoding == Encoding::ISO_8859_1) && s.valid_encoding?
         return s
@@ -69,7 +74,8 @@ module NewRelic
         return object if object.empty?
         hash = {}
         object.each_pair do |k, v|
-          k = normalize_string(k) if k.is_a?(String)
+          k = normalize_string(k)      if k.is_a?(String)
+          k = normalize_string(k.to_s) if k.is_a?(Symbol)
           hash[k] = normalize(v)
         end
         hash

data/lib/new_relic/rack/browser_monitoring.rb

@@ -15,6 +15,10 @@ module NewRelic::Rack
   # @api public
   #
   class BrowserMonitoring < AgentMiddleware
+    # The maximum number of bytes of the response body that we will
+    # examine in order to look for a RUM insertion point.
+    SCAN_LIMIT = 50_000
+
     def traced_call(env)
       result = @app.call(env)   # [status, headers, response]
 
@@ -38,8 +42,23 @@ module NewRelic::Rack
     def should_instrument?(env, status, headers)
       status == 200 &&
         !env[ALREADY_INSTRUMENTED_KEY] &&
-        headers["Content-Type"] && headers["Content-Type"].include?("text/html") &&
-        !headers['Content-Disposition'].to_s.include?('attachment')
+        is_html?(headers) &&
+        !is_attachment?(headers) &&
+        !is_streaming?(env)
+    end
+
+    def is_html?(headers)
+      headers["Content-Type"] && headers["Content-Type"].include?("text/html")
+    end
+
+    def is_attachment?(headers)
+      headers['Content-Disposition'].to_s.include?('attachment')
+    end
+
+    def is_streaming?(env)
+      return false unless defined?(ActionController::Live)
+
+      env['action_controller.instance'].class.included_modules.include?(ActionController::Live)
     end
 
     CHARSET_RE         = /<\s*meta[^>]+charset\s*=[^>]*>/im.freeze
@@ -51,7 +70,7 @@ module NewRelic::Rack
       return nil unless source
 
       # Only scan the first 50k (roughly) then give up.
-      beginning_of_source = source[0..50_000]
+      beginning_of_source = source[0..SCAN_LIMIT]
 
       if body_start = find_body_start(beginning_of_source)
         meta_tag_positions = [
@@ -73,7 +92,9 @@ module NewRelic::Rack
           NewRelic::Agent.logger.debug "Skipping RUM instrumentation. Could not properly determine location to inject script."
         end
       else
-        NewRelic::Agent.logger.debug "Skipping RUM instrumentation. Unable to find <body> tag in document."
+        msg = "Skipping RUM instrumentation. Unable to find <body> tag in first #{SCAN_LIMIT} bytes of document."
+        NewRelic::Agent.logger.log_once(:warn, :rum_insertion_failure, msg)
+        NewRelic::Agent.logger.debug(msg)
       end
 
       if headers['Content-Length']

data/lib/new_relic/version.rb

@@ -12,7 +12,7 @@ module NewRelic
 
     MAJOR = 3
     MINOR = 9
-    TINY  = 0
+    TINY  = 1
 
     begin
       require File.join(File.dirname(__FILE__), 'build')

data/newrelic_rpm.gemspec

@@ -39,7 +39,6 @@ EOS
   s.require_paths = ["lib"]
   s.rubygems_version = Gem::VERSION
   s.summary = "New Relic Ruby Agent"
-  s.post_install_message = NewRelic::LatestChanges.read
 
   s.add_development_dependency 'rake', '10.1.0'
   s.add_development_dependency 'minitest', '~> 4.7.5'

data/test/agent_helper.rb

@@ -244,6 +244,10 @@ def in_transaction(*args)
   val
 end
 
+def stub_transaction_guid(guid)
+  NewRelic::Agent::Transaction.tl_current.instance_variable_set(:@guid, guid)
+end
+
 # Convenience wrapper around in_transaction that sets the category so that it
 # looks like we are in a web transaction
 def in_web_transaction(name='dummy')
@@ -252,6 +256,32 @@ def in_web_transaction(name='dummy')
   end
 end
 
+def in_background_transaction(name='silly')
+  in_transaction(name, :category => :task) do
+    yield
+  end
+end
+
+def last_traced_error
+  NewRelic::Agent.agent.error_collector.errors.last
+end
+
+def last_traced_error_request_params
+  last_traced_error.params[:request_params]
+end
+
+def last_transaction_trace
+  NewRelic::Agent.agent.transaction_sampler.last_sample
+end
+
+def last_transaction_trace_request_params
+  last_transaction_trace.params[:request_params]
+end
+
+def last_sql_trace
+  NewRelic::Agent.agent.sql_sampler.sql_traces.values.last
+end
+
 def find_last_transaction_segment(transaction_sample=nil)
   if transaction_sample
     root_segment = transaction_sample.root_segment
@@ -457,3 +487,49 @@ ensure
     NewRelic::Agent.ignore_error_filter(&original_filter)
   end
 end
+
+def json_dump_and_encode(object)
+  Base64.encode64(NewRelic::JSONWrapper.dump(object))
+end
+
+def get_last_analytics_event
+  NewRelic::Agent.agent.instance_variable_get(:@request_sampler).samples.last
+end
+
+def cross_agent_tests_dir
+  File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', 'cross_agent_tests'))
+end
+
+def load_cross_agent_test(name)
+  test_file_path = File.join(cross_agent_tests_dir, "#{name}.json")
+  data = File.read(test_file_path)
+  NewRelic::JSONWrapper.load(data)
+end
+
+def assert_event_attributes(event, test_name, expected_attributes, non_expected_attributes)
+  incorrect_attributes = []
+
+  event_attrs = event[0]
+
+  expected_attributes.each do |name, expected_value|
+    actual_value = event_attrs[name]
+    incorrect_attributes << name unless actual_value == expected_value
+  end
+
+  msg = "Found missing or incorrect attribute values in #{test_name}:\n"
+
+  incorrect_attributes.each do |name|
+    msg << "  #{name}: expected = #{expected_attributes[name].inspect}, actual = #{event_attrs[name].inspect}\n"
+  end
+  msg << "\n"
+
+  msg << "All event values:\n"
+  event_attrs.each do |name, actual_value|
+    msg << "  #{name}: #{actual_value.inspect}\n"
+  end
+  assert(incorrect_attributes.empty?, msg)
+
+  non_expected_attributes.each do |name|
+    assert_nil(event_attrs[name], "Found value '#{event_attrs[name]}' for attribute '#{name}', but expected nothing in #{test_name}")
+  end
+end