newrelic_rpm 3.9.4.245 → 3.9.5.251

data/lib/new_relic/agent/method_tracer_helpers.rb

@@ -0,0 +1,90 @@
+# 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 MethodTracerHelpers
+      extend self
+
+      # helper for logging errors to the newrelic_agent.log
+      # properly. Logs the error at error level
+      def log_errors(code_area)
+        yield
+      rescue => e
+        ::NewRelic::Agent.logger.error("Caught exception in #{code_area}.", e)
+      end
+
+      def trace_execution_scoped_header(state, t0)
+        log_errors(:trace_execution_scoped_header) do
+          stack = state.traced_method_stack
+          stack.push_frame(state, :method_tracer, t0)
+        end
+      end
+
+      def record_metrics(state, first_name, other_names, duration, exclusive, options)
+        record_scoped_metric = options.has_key?(:scoped_metric) ? options[:scoped_metric] : true
+        stat_engine = NewRelic::Agent.instance.stats_engine
+        if record_scoped_metric
+          stat_engine.record_scoped_and_unscoped_metrics(state, first_name, other_names, duration, exclusive)
+        else
+          metrics = [first_name].concat(other_names)
+          stat_engine.record_unscoped_metrics(state, metrics, duration, exclusive)
+        end
+      end
+
+      def trace_execution_scoped_footer(state, t0, first_name, metric_names, expected_frame, options, t1=Time.now.to_f)
+        log_errors(:trace_method_execution_footer) do
+          if expected_frame
+            stack = state.traced_method_stack
+            create_metrics = options.has_key?(:metric) ? options[:metric] : true
+            frame = stack.pop_frame(state, expected_frame, first_name, t1, create_metrics)
+            if create_metrics
+              duration = t1 - t0
+              exclusive = duration - frame.children_time
+
+              if duration < 1_000_000_000 # roughly 31 years
+                if duration < 0
+                  ::NewRelic::Agent.logger.log_once(:warn, "metric_duration_negative:#{first_name}",
+                    "Metric #{first_name} has negative duration: #{duration} s")
+                end
+
+                if exclusive < 0
+                  ::NewRelic::Agent.logger.log_once(:warn, "metric_exclusive_negative:#{first_name}",
+                    "Metric #{first_name} has negative exclusive time: duration = #{duration} s, child_time = #{frame.children_time}")
+                end
+
+                record_metrics(state, first_name, metric_names, duration, exclusive, options)
+              else
+                ::NewRelic::Agent.logger.log_once(:warn, "too_huge_metric:#{first_name}",
+                  "Ignoring metric #{first_name} with unacceptably large duration: #{duration} s")
+              end
+            end
+          end
+        end
+      end
+
+      def trace_execution_scoped(metric_names, options={}) #THREAD_LOCAL_ACCESS
+        state = NewRelic::Agent::TransactionState.tl_get
+        return yield unless state.is_execution_traced?
+
+        metric_names = Array(metric_names)
+        first_name   = metric_names.shift
+        return yield unless first_name
+
+        additional_metrics_callback = options[:additional_metrics_callback]
+        start_time = Time.now.to_f
+        expected_scope = trace_execution_scoped_header(state, start_time)
+
+        begin
+          result = yield
+          metric_names += Array(additional_metrics_callback.call) if additional_metrics_callback
+          result
+        ensure
+          trace_execution_scoped_footer(state, start_time, first_name, metric_names, expected_scope, options)
+        end
+      end
+
+    end
+  end
+end

data/lib/new_relic/agent/new_relic_service.rb

@@ -124,22 +124,26 @@ module NewRelic
         metric_data_array = build_metric_data_array(stats_hash)
         result = invoke_remote(
           :metric_data,
-          [@agent_id, timeslice_start.to_f, timeslice_end.to_f, metric_data_array]
+          [@agent_id, timeslice_start.to_f, timeslice_end.to_f, metric_data_array],
+          :item_count => metric_data_array.size
         )
         fill_metric_id_cache(result)
         result
       end
 
       def error_data(unsent_errors)
-        invoke_remote(:error_data, [@agent_id, unsent_errors])
+        invoke_remote(:error_data, [@agent_id, unsent_errors],
+          :item_count => unsent_errors.size)
       end
 
       def transaction_sample_data(traces)
-        invoke_remote(:transaction_sample_data, [@agent_id, traces])
+        invoke_remote(:transaction_sample_data, [@agent_id, traces],
+          :item_count => traces.size)
       end
 
       def sql_trace_data(sql_traces)
-        invoke_remote(:sql_trace_data, [sql_traces])
+        invoke_remote(:sql_trace_data, [sql_traces],
+          :item_count => sql_traces.size)
       end
 
       def profile_data(profile)
@@ -160,7 +164,8 @@ module NewRelic
 
       # Send fine-grained analytic data to the collector.
       def analytic_event_data(data)
-        invoke_remote(:analytic_event_data, [@agent_id, data])
+        invoke_remote(:analytic_event_data, [@agent_id, data],
+          :item_count => data.size)
       end
 
       # We do not compress if content is smaller than 64kb.  There are
@@ -332,7 +337,10 @@ module NewRelic
                                 :collector => @collector)
         @marshaller.load(decompress_response(response))
       ensure
-        record_supportability_metrics(method, start_ts, serialize_finish_ts, size)
+        record_timing_supportability_metrics(method, start_ts, serialize_finish_ts)
+        if size
+          record_size_supportability_metrics(method, size, options[:item_count])
+        end
       end
 
       def handle_serialization_error(method, e)
@@ -344,7 +352,7 @@ module NewRelic
         raise error
       end
 
-      def record_supportability_metrics(method, start_ts, serialize_finish_ts, size)
+      def record_timing_supportability_metrics(method, start_ts, serialize_finish_ts)
         serialize_time = serialize_finish_ts && (serialize_finish_ts - start_ts)
         duration = (Time.now - start_ts).to_f
         NewRelic::Agent.record_metric("Supportability/invoke_remote", duration)
@@ -353,10 +361,24 @@ module NewRelic
           NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize", serialize_time)
           NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize/#{method.to_s}", serialize_time)
         end
-        if size
-          NewRelic::Agent.record_metric("Supportability/invoke_remote_size", size)
-          NewRelic::Agent.record_metric("Supportability/invoke_remote_size/#{method.to_s}", size)
-        end
+      end
+
+      # For these metrics, we use the following fields:
+      # call_count           => number of times this remote method was invoked
+      # total_call_time      => total size in bytes of payloads across all invocations
+      # total_exclusive_time => total size in items (e.g. unique metrics, traces, events, etc) across all invocations
+      #
+      # The last field doesn't make sense for all methods (e.g. get_agent_commands),
+      # so we omit it for those methods that don't really take collections
+      # of items as arguments.
+      def record_size_supportability_metrics(method, size_bytes, item_count)
+        metrics = [
+          "Supportability/invoke_remote_size",
+          "Supportability/invoke_remote_size/#{method.to_s}"
+        ]
+        # we may not have an item count, in which case, just record 0 for the exclusive time
+        item_count ||= 0
+        NewRelic::Agent.agent.stats_engine.tl_record_unscoped_metrics(metrics, size_bytes, item_count)
       end
 
       # Raises an UnrecoverableServerException if the post_string is longer

data/lib/new_relic/agent/new_relic_service/encoders.rb

@@ -10,21 +10,25 @@ module NewRelic
     class NewRelicService
       module Encoders
         module Identity
-          def self.encode(data)
+          def self.encode(data, opts=nil)
             data
           end
         end
 
         module Compressed
-          def self.encode(data)
+          def self.encode(data, opts=nil)
             Zlib::Deflate.deflate(data, Zlib::DEFAULT_COMPRESSION)
           end
         end
 
         module Base64CompressedJSON
-          def self.encode(data)
-            json = ::NewRelic::JSONWrapper.dump(data,
-              :normalize => Agent.config[:normalize_json_string_encodings])
+          def self.encode(data, opts={})
+            normalize_encodings = if opts[:skip_normalization]
+              false
+            else
+              Agent.config[:normalize_json_string_encodings]
+            end
+            json = ::NewRelic::JSONWrapper.dump(data, :normalize => normalize_encodings)
             Base64.encode64(Compressed.encode(json))
           end
         end

data/lib/new_relic/agent/request_sampler.rb

@@ -13,20 +13,21 @@ class NewRelic::Agent::RequestSampler
           MonitorMixin
 
   # The type field of the sample
-  SAMPLE_TYPE              = 'Transaction'
+  SAMPLE_TYPE              = 'Transaction'.freeze
 
   # Strings for static keys of the sample structure
-  TYPE_KEY                       = 'type'
-  TIMESTAMP_KEY                  = 'timestamp'
-  NAME_KEY                       = 'name'
-  DURATION_KEY                   = 'duration'
-  GUID_KEY                       = 'nr.guid'
-  REFERRING_TRANSACTION_GUID_KEY = 'nr.referringTransactionGuid'
-  CAT_TRIP_ID_KEY                = 'nr.tripId'
-  CAT_PATH_HASH_KEY              = 'nr.pathHash'
-  CAT_REFERRING_PATH_HASH_KEY    = 'nr.referringPathHash'
-  CAT_ALTERNATE_PATH_HASHES_KEY  = 'nr.alternatePathHashes'
-  APDEX_PERF_ZONE_KEY            = 'nr.apdexPerfZone'
+  TYPE_KEY                       = 'type'.freeze
+  TIMESTAMP_KEY                  = 'timestamp'.freeze
+  NAME_KEY                       = 'name'.freeze
+  DURATION_KEY                   = 'duration'.freeze
+  HTTP_RESPONSE_CODE_KEY         = 'httpResponseCode'.freeze
+  GUID_KEY                       = 'nr.guid'.freeze
+  REFERRING_TRANSACTION_GUID_KEY = 'nr.referringTransactionGuid'.freeze
+  CAT_TRIP_ID_KEY                = 'nr.tripId'.freeze
+  CAT_PATH_HASH_KEY              = 'nr.pathHash'.freeze
+  CAT_REFERRING_PATH_HASH_KEY    = 'nr.referringPathHash'.freeze
+  CAT_ALTERNATE_PATH_HASHES_KEY  = 'nr.alternatePathHashes'.freeze
+  APDEX_PERF_ZONE_KEY            = 'nr.apdexPerfZone'.freeze
 
   def initialize( event_listener )
     super()
@@ -185,10 +186,17 @@ class NewRelic::Agent::RequestSampler
     optionally_append(CAT_PATH_HASH_KEY,              :cat_path_hash, sample, payload)
     optionally_append(CAT_REFERRING_PATH_HASH_KEY,    :cat_referring_path_hash, sample, payload)
     optionally_append(APDEX_PERF_ZONE_KEY,            :apdex_perf_zone, sample, payload)
+    append_http_response_code(sample, payload)
     append_cat_alternate_path_hashes(sample, payload)
     sample
   end
 
+  def append_http_response_code(sample, payload)
+    unless NewRelic::Agent.config[:disable_middleware_instrumentation]
+      optionally_append(HTTP_RESPONSE_CODE_KEY, :http_response_code, sample, payload)
+    end
+  end
+
   def append_cat_alternate_path_hashes(sample, payload)
     if payload.include?(:cat_alternate_path_hashes)
       sample[CAT_ALTERNATE_PATH_HASHES_KEY] = payload[:cat_alternate_path_hashes].sort.join(',')

data/lib/new_relic/agent/rules_engine.rb

@@ -2,103 +2,56 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
+require 'new_relic/agent/rules_engine/replacement_rule'
+require 'new_relic/agent/rules_engine/segment_terms_rule'
+
 module NewRelic
   module Agent
     class RulesEngine
+      SEGMENT_SEPARATOR = '/'.freeze
+      LEADING_SLASH_REGEX = %r{^/}.freeze
+
       include Enumerable
       extend Forwardable
 
       def_delegators :@rules, :size, :inspect, :each, :clear
 
-      def self.from_specs(specs)
-        rules = (specs || []).map { |spec| Rule.new(spec) }
+      def self.create_metric_rules(connect_response)
+        specs = connect_response['metric_name_rules'] || []
+        rules = specs.map { |spec| ReplacementRule.new(spec) }
         self.new(rules)
       end
 
-      def initialize(rules=[])
-        @rules = rules.sort
-      end
-
-      def << rule
-        @rules << rule
-        @rules.sort!
-        @rules
-      end
-
-      def rename(original_string)
-        @rules.inject(original_string) do |string,rule|
-          if rule.each_segment
-            segments = string.split('/')
-
-            # If string looks like '/foo/bar', we want to
-            # ignore the empty string preceding the first slash.
-            add_preceding_slash = false
-            if segments[0] == ''
-              segments.shift
-              add_preceding_slash = true
-            end
+      def self.create_transaction_rules(connect_response)
+        txn_name_specs     = connect_response['transaction_name_rules']    || []
+        segment_rule_specs = connect_response['transaction_segment_terms'] || []
 
-            result, matched = rule.map_to_list(segments)
-            result = result.join('/') if !result.nil?
-            result = '/'+result if add_preceding_slash
-          else
-            result, matched = rule.apply(string)
-          end
+        txn_name_rules = txn_name_specs.map     { |s| ReplacementRule.new(s) }
+        segment_rules  = segment_rule_specs.map { |s| SegmentTermsRule.new(s) }
 
-          break result if (matched && rule.terminate_chain) || result.nil?
-          result
-        end
+        self.new(txn_name_rules, segment_rules)
       end
 
-      class Rule
-        attr_reader(:terminate_chain, :each_segment, :ignore, :replace_all, :eval_order,
-                    :match_expression, :replacement)
-
-        def initialize(options)
-          if !options['match_expression']
-            raise ArgumentError.new('missing required match_expression')
-          end
-          if !options['replacement'] && !options['ignore']
-            raise ArgumentError.new('must specify replacement when ignore is false')
-          end
-
-          @match_expression = Regexp.new(options['match_expression'], Regexp::IGNORECASE)
-          @replacement      = options['replacement']
-          @ignore           = options['ignore'] || false
-          @eval_order       = options['eval_order'] || 0
-          @replace_all      = options['replace_all'] || false
-          @each_segment     = options['each_segment'] || false
-          @terminate_chain  = options['terminate_chain'] || false
-        end
-
-        def apply(string)
-          if @ignore
-            if string.match @match_expression
-              [nil, true]
-            else
-              [string, false]
-            end
-          else
-            method = @replace_all ? :gsub : :sub
-            result = string.send(method, @match_expression, @replacement)
-            match_found = ($~ != nil)
-            [result, match_found]
-          end
-        end
+      def initialize(rules=[], segment_term_rules=[])
+        @rules = rules.sort
+        @segment_term_rules = segment_term_rules
+      end
 
-        def map_to_list(list)
-          matched = false
-          result = list.map do |string|
-            str_result, str_match = apply(string)
-            matched ||= str_match
-            str_result
+      def apply_rules(rules, string)
+        rules.each do |rule|
+          if rule.matches?(string)
+            string = rule.apply(string)
+            break if rule.terminal?
           end
-          [result, matched]
         end
+        string
+      end
 
-        def <=>(other)
-          eval_order <=> other.eval_order
-        end
+      def rename(original_string)
+        renamed = apply_rules(@rules, original_string)
+        return nil unless renamed
+        renamed = apply_rules(@segment_term_rules, renamed)
+        renamed
       end
     end
   end

data/lib/new_relic/agent/rules_engine/replacement_rule.rb

@@ -0,0 +1,76 @@
+# 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
+    class RulesEngine
+      class ReplacementRule
+        attr_reader(:terminate_chain, :each_segment, :ignore, :replace_all, :eval_order,
+                    :match_expression, :replacement)
+
+        def initialize(options)
+          if !options['match_expression']
+            raise ArgumentError.new('missing required match_expression')
+          end
+          if !options['replacement'] && !options['ignore']
+            raise ArgumentError.new('must specify replacement when ignore is false')
+          end
+
+          @match_expression = Regexp.new(options['match_expression'], Regexp::IGNORECASE)
+          @replacement      = options['replacement']
+          @ignore           = options['ignore'] || false
+          @eval_order       = options['eval_order'] || 0
+          @replace_all      = options['replace_all'] || false
+          @each_segment     = options['each_segment'] || false
+          @terminate_chain  = options['terminate_chain'] || false
+        end
+
+        def terminal?
+          @terminate_chain || @ignore
+        end
+
+        def matches?(string)
+          if @each_segment
+            string.split(SEGMENT_SEPARATOR).any? do |segment|
+              segment.match(@match_expression)
+            end
+          else
+            string.match @match_expression
+          end
+        end
+
+        def apply(string)
+          if @ignore
+            nil
+          elsif @each_segment
+            apply_to_each_segment(string)
+          else
+            apply_replacement(string)
+          end
+        end
+
+        def apply_replacement(string)
+          method = @replace_all ? :gsub : :sub
+          string.send(method, @match_expression, @replacement)
+        end
+
+        def apply_to_each_segment(string)
+          string        = string.dup
+          leading_slash = string.slice!(LEADING_SLASH_REGEX)
+          segments      = string.split(SEGMENT_SEPARATOR)
+
+          segments.map! do |segment|
+            apply_replacement(segment)
+          end
+
+          "#{leading_slash}#{segments.join(SEGMENT_SEPARATOR)}"
+        end
+
+        def <=>(other)
+          eval_order <=> other.eval_order
+        end
+      end
+    end
+  end
+end