newrelic_rpm 3.5.7.59 → 3.5.8.64.beta

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

@@ -300,17 +300,30 @@ module NewRelic
         end
 
         def self.record_apdex(current_metric, action_duration, total_duration, is_error)
-          summary_stat = agent.stats_engine.get_custom_stats("Apdex", NewRelic::ApdexStats)
-          controller_stat = agent.stats_engine.get_custom_stats(current_metric.apdex_metric_path, NewRelic::ApdexStats)
+          summary_stat = agent.stats_engine.lookup_stats("Apdex") ||
+            initialize_apdex("Apdex")
           update_apdex(summary_stat, total_duration, is_error)
+
+          controller_stat = agent.stats_engine.lookup_stats(current_metric.apdex_metric_path) ||
+            initialize_apdex(current_metric.apdex_metric_path)
           update_apdex(controller_stat, action_duration, is_error)
         end
 
+        # Apdex min and max values should be initialized to the
+        # current apdex_t
+        def self.initialize_apdex(metric_name)
+          stats = agent.stats_engine.get_stats_no_scope(metric_name)
+          apdex_t = TransactionInfo.get.apdex_t
+          stats.min_call_time = apdex_t
+          stats.max_call_time = apdex_t
+          return stats
+        end
+
         # Record an apdex value for the given stat.  when `failed`
         # the apdex should be recorded as a failure regardless of duration.
         def self.update_apdex(stat, duration, failed)
           duration = duration.to_f
-          apdex_t = Agent.config[:apdex_t]
+          apdex_t = TransactionInfo.get.apdex_t
           case
           when failed
             stat.record_apdex_f

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

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 DependencyDetection.defer do
   @name = :net
 
@@ -7,23 +9,23 @@ DependencyDetection.defer do
   
   executes do
     ::NewRelic::Agent.logger.info 'Installing Net instrumentation'
+    require 'new_relic/agent/cross_app_tracing'
   end
-  
+
   executes do
-    Net::HTTP.class_eval do
-      def request_with_newrelic_trace(*args, &block)
-        metrics = ["External/#{@address}/Net::HTTP/#{args[0].method}", "External/#{@address}/all", "External/all"]
-        if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
-          metrics << "External/allWeb"
-        else
-          metrics << "External/allOther"
-        end
-        self.class.trace_execution_scoped metrics do
-          request_without_newrelic_trace(*args, &block)
+    class Net::HTTP
+
+      # Instrument outgoing HTTP requests and fire associated events back
+      # into the Agent.
+      def request_with_newrelic_trace(request, *args, &block)
+        NewRelic::Agent::CrossAppTracing.trace_http_request( self, request ) do
+          request_without_newrelic_trace( request, *args, &block )
         end
       end
+
       alias request_without_newrelic_trace request
       alias request request_with_newrelic_trace
+
     end
   end
 end

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

@@ -1,6 +1,6 @@
 DependencyDetection.defer do
   @name = :resque
-  
+
   depends_on do
     defined?(::Resque::Job) && !NewRelic::Agent.config[:disable_resque]  &&
       !NewRelic::LanguageSupport.using_version?('1.9.1')
@@ -9,19 +9,19 @@ DependencyDetection.defer do
   executes do
     ::NewRelic::Agent.logger.info 'Installing Resque instrumentation'
   end
-  
+
   executes do
     # == Resque Instrumentation
     #
     # Installs a hook to ensure the agent starts manually when the worker
     # starts and also adds the tracer to the process method which executes
     # in the forked task.
-    
+
     module Resque
       module Plugins
         module NewRelicInstrumentation
           include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-          
+
           def around_perform_with_monitoring(*args)
             begin
               perform_action_with_newrelic_trace(:name => 'perform',
@@ -36,7 +36,7 @@ DependencyDetection.defer do
         end
       end
     end
-    
+
     module NewRelic
       module Agent
         module Instrumentation
@@ -51,13 +51,13 @@ DependencyDetection.defer do
         end
       end
     end
-    
+
     ::Resque::Job.class_eval do
       def self.new(*args)
         super(*args).extend NewRelic::Agent::Instrumentation::ResqueInstrumentationInstaller
       end
     end
-    
+
     if NewRelic::LanguageSupport.can_fork?
       ::Resque.before_first_fork do
         NewRelic::Agent.manual_start(:dispatcher   => :resque,
@@ -65,17 +65,17 @@ DependencyDetection.defer do
                                      :start_channel_listener => true,
                                      :report_instance_busy => false)
       end
-      
+
       ::Resque.before_fork do |job|
         NewRelic::Agent.register_report_channel(job.object_id)
       end
-      
+
       ::Resque.after_fork do |job|
         NewRelic::Agent.after_fork(:report_to_channel => job.object_id)
       end
     end
   end
-end 
+end
 
 # call this now so it is memoized before potentially forking worker processes
 NewRelic::LanguageSupport.can_fork?

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

@@ -37,26 +37,33 @@ module NewRelic
         include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
         def dispatch_with_newrelic
+          # We're trying to determine the transaction name via Sinatra's
+          # process_route, but calling it here misses Sinatra's normal error handling.
+          #
+          # Relies on transaction_name to always safely return a value for us
           txn_name = NewRelic.transaction_name(self.class.routes, @request) do |pattern, keys, conditions|
-            process_route(pattern, keys, conditions) do
+            result = process_route(pattern, keys, conditions) do
               pattern.source
             end
+            result if result.class == String
           end
 
           perform_action_with_newrelic_trace(:category => :sinatra,
                                              :name => txn_name,
                                              :params => @request.params) do
-            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
+            dispatch_and_notice_errors_with_newrelic
           end
         end
 
+        def dispatch_and_notice_errors_with_newrelic
+          dispatch_without_newrelic
+        ensure
+          # 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
+        end
+
         # Define Request Header accessor for Sinatra
         def newrelic_request_headers
           request.env
@@ -89,6 +96,9 @@ module NewRelic
             end
 
             name
+          rescue => e
+            ::NewRelic::Agent.logger.debug("#{e.class} : #{e.message} - Error encountered trying to identify Sinatra transaction name")
+            '(unknown)'
           end
         end
       end

data/lib/new_relic/agent/new_relic_service.rb

@@ -7,7 +7,8 @@ module NewRelic
       # Specifies the version of the agent's communication protocol with
       # the NewRelic hosted site.
 
-      PROTOCOL_VERSION = 10
+      PROTOCOL_VERSION = 12
+      # 1f147a42: v10 (tag 3.5.3.17)
       # cf0d1ff1: v9 (tag 3.5.0)
       # 14105: v8 (tag 2.10.3)
       # (no v7)
@@ -18,12 +19,13 @@ module NewRelic
       # 534:   v2 (shows up in 2.1.0, our first tag)
 
       attr_accessor :request_timeout, :agent_id
-      attr_reader :collector, :marshaller
+      attr_reader :collector, :marshaller, :metric_id_cache
 
       def initialize(license_key=nil, collector=control.server)
         @license_key = license_key || Agent.config[:license_key]
         @collector = collector
         @request_timeout = Agent.config[:timeout]
+        @metric_id_cache = {}
 
         @audit_logger = ::NewRelic::Agent::AuditLogger.new(Agent.config)
         Agent.config.register_callback(:'audit_log.enabled') do |enabled|
@@ -70,9 +72,47 @@ module NewRelic
         invoke_remote(:shutdown, @agent_id, time.to_i) if @agent_id
       end
 
+      def reset_metric_id_cache
+        @metric_id_cache = {}
+      end
+
+      # takes an array of arrays of spec and id, adds it into the
+      # metric cache so we can save the collector some work by
+      # sending integers instead of strings the next time around
+      def fill_metric_id_cache(pairs_of_specs_and_ids)
+        Array(pairs_of_specs_and_ids).each do |metric_spec_hash, metric_id|
+          metric_spec = MetricSpec.new(metric_spec_hash['name'],
+                                       metric_spec_hash['scope'])
+          metric_id_cache[metric_spec] = metric_id
+        end
+      end
+
+      # The collector wants to recieve metric data in a format that's different
+      # from how we store it internally, so this method handles the translation.
+      # It also handles translating metric names to IDs using our metric ID cache.
+      def build_metric_data_array(stats_hash)
+        metric_data_array = []
+        stats_hash.each do |metric_spec, stats|
+          # Omit empty stats as an optimization
+          unless stats.is_reset?
+            metric_id = metric_id_cache[metric_spec]
+            metric_data = if metric_id
+              NewRelic::MetricData.new(nil, stats, metric_id)
+            else
+              NewRelic::MetricData.new(metric_spec, stats, nil)
+            end
+            metric_data_array << metric_data
+          end
+        end
+        metric_data_array
+      end
+
       def metric_data(last_harvest_time, now, unsent_timeslice_data)
-        invoke_remote(:metric_data, @agent_id, last_harvest_time, now,
-                      unsent_timeslice_data)
+        metric_data_array = build_metric_data_array(unsent_timeslice_data)
+        result = invoke_remote(:metric_data, @agent_id, last_harvest_time, now,
+                                metric_data_array)
+        fill_metric_id_cache(result)
+        result
       end
 
       def error_data(unsent_errors)
@@ -207,7 +247,14 @@ module NewRelic
       def invoke_remote(method, *args)
         now = Time.now
 
-        data = @marshaller.dump(args)
+        data = nil
+        begin
+          data = @marshaller.dump(args)
+        rescue JsonError
+          @marshaller = PrubyMarshaller.new
+          retry
+        end
+
         data, encoding = compress_request_if_needed(data)
 
         uri = remote_method_uri(method, @marshaller.format)
@@ -341,6 +388,12 @@ module NewRelic
         end
       end
 
+      # Used to wrap errors reported to agent by the collector
+      class CollectorError < StandardError; end
+
+      # Used to wrap any problem with the JSON marshaller
+      class JsonError < StandardError; end
+
       class Marshaller
         def parsed_error(error)
           error_class = error['error_type'].split('::') \
@@ -426,13 +479,16 @@ module NewRelic
 
         def dump(ruby, opts={})
           JSON.dump(prepare(ruby, opts))
+        rescue => e
+          ::NewRelic::Agent.logger.debug "#{e.class.name} : #{e.message} encountered dumping agent data: #{ruby}"
+          raise JsonError.new(e)
         end
 
         def load(data)
           return unless data && data != ''
           return_value(JSON.load(data))
-        rescue
-          ::NewRelic::Agent.logger.debug "Error encountered loading collector response: #{data}"
+        rescue => e
+          ::NewRelic::Agent.logger.debug "#{e.class.name} : #{e.message} encountered loading collector response: #{data}"
           raise
         end
 
@@ -452,8 +508,6 @@ module NewRelic
           true # for some definitions of 'human'
         end
       end
-
-      class CollectorError < StandardError; end
     end
   end
 end

data/lib/new_relic/agent/pipe_service.rb

@@ -3,13 +3,13 @@ module NewRelic
     class PipeService
       attr_reader :channel_id, :buffer
       attr_accessor :request_timeout, :agent_id, :collector
-      
+
       def initialize(channel_id)
         @channel_id = channel_id
         @collector = NewRelic::Control::Server.new(:name => 'parent',
                                                    :port => 0)
       end
-      
+
       def connect(config)
         nil
       end
@@ -19,7 +19,7 @@ module NewRelic
       end
 
       def metric_data(last_harvest_time, now, unsent_timeslice_data)
-        write_to_pipe(:stats => hash_from_metric_data(unsent_timeslice_data))
+        write_to_pipe(:stats => unsent_timeslice_data)
         {}
       end
 
@@ -34,7 +34,7 @@ module NewRelic
       def sql_trace_data(sql)
         write_to_pipe(:sql_traces => sql) if sql
       end
-      
+
       def shutdown(time)
         write_to_pipe('EOF')
         NewRelic::Agent::PipeChannelManager.channels[@channel_id].close
@@ -46,17 +46,13 @@ module NewRelic
       def session
         yield
       end
-      
-      private
 
-      def hash_from_metric_data(metric_data)
-        metric_hash = {}
-        metric_data.each do |metric_entry|
-          metric_hash[metric_entry.metric_spec] = metric_entry
-        end
-        metric_hash
+      def reset_metric_id_cache
+        # we don't cache metric IDs, so nothing to do
       end
 
+      private
+
       def write_to_pipe(data)
         NewRelic::Agent::PipeChannelManager.channels[@channel_id].write(data)
       rescue => e

data/lib/new_relic/agent/rules_engine.rb

@@ -0,0 +1,72 @@
+module NewRelic
+  module Agent
+    class RulesEngine
+      include Enumerable
+      extend Forwardable
+
+      def_delegators :@rules, :size, :<<, :inspect, :each
+
+      attr_accessor :rules
+
+      def initialize(rules=[])
+        @rules = rules
+      end
+
+      def rename(original_string)
+        @rules.sort.inject(original_string) do |string,rule|
+          if rule.each_segment
+            result, matched = rule.map_to_list(string.split('/'))
+            result = result.join('/')
+          else
+            result, matched = rule.apply(string)
+          end
+
+          break result if matched && rule.terminate_chain
+          result
+        end
+      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'])
+          @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)
+          method = @replace_all ? :gsub : :sub
+          result = string.send(method, @match_expression, @replacement)
+          [result, result != string]
+        end
+
+        def map_to_list(list)
+          matched = false
+          result = list.map do |string|
+            str_result, str_match = apply(string)
+            matched ||= str_match
+            str_result
+          end
+          [result, matched]
+        end
+
+        def <=>(other)
+          eval_order <=> other.eval_order
+        end
+      end
+    end
+  end
+end