newrelic_rpm 3.10.0.279 → 3.11.0.283

data/lib/new_relic/agent/transaction_event_aggregator.rb

@@ -186,14 +186,10 @@ class NewRelic::Agent::TransactionEventAggregator
 
   # Web Metrics
   map_metric('WebFrontend/QueueTime', :total_call_time => "queueDuration")
-  map_metric('Memcache/allWeb',       :total_call_time => "memcacheDuration")
-
   map_metric('External/allWeb',       :total_call_time => "externalDuration")
   map_metric('External/allWeb',       :call_count      => "externalCallCount")
 
   # Background Metrics
-  map_metric('Memcache/allOther',     :total_call_time => "memcacheDuration")
-
   map_metric('External/allOther',     :total_call_time => "externalDuration")
   map_metric('External/allOther',     :call_count      => "externalCallCount")
 

data/lib/new_relic/agent/transaction_sampler.rb

@@ -182,11 +182,16 @@ module NewRelic
         return unless builder
         segment = builder.current_segment
         if segment
-          if key != :sql
-            segment[key] = self.class.truncate_message(message)
+          if key == :sql
+            sql = segment[:sql]
+            if(sql && !sql.empty?)
+              sql = self.class.truncate_message(sql << "\n#{message}") if sql.length <= MAX_DATA_LENGTH
+            else
+              # message is expected to have been pre-truncated by notice_sql
+              segment[:sql] = message
+            end
           else
-            # message is expected to have been pre-truncated by notice_sql
-            segment[key] = message
+            segment[key] = self.class.truncate_message(message)
           end
           append_backtrace(segment, duration)
         end
@@ -199,7 +204,8 @@ module NewRelic
       # the UI
       def self.truncate_message(message)
         if message.length > (MAX_DATA_LENGTH - 4)
-          message[0..MAX_DATA_LENGTH - 4] + '...'
+          message.slice!(MAX_DATA_LENGTH - 4..message.length)
+          message << "..."
         else
           message
         end

data/lib/new_relic/rack/error_collector.rb

@@ -3,7 +3,6 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require 'new_relic/rack/agent_middleware'
-require 'new_relic/agent/instrumentation/middleware_proxy'
 
 module NewRelic::Rack
   # This middleware is no longer used by the agent by default, but remains here

data/lib/new_relic/version.rb

@@ -11,7 +11,7 @@ module NewRelic
     end
 
     MAJOR = 3
-    MINOR = 10
+    MINOR = 11
     TINY  = 0
 
     begin

data/lib/sequel/extensions/newrelic_instrumentation.rb

@@ -5,7 +5,8 @@
 
 require 'sequel' unless defined?( Sequel )
 require 'newrelic_rpm' unless defined?( NewRelic )
-require 'new_relic/agent/instrumentation/active_record_helper'
+require 'new_relic/agent/instrumentation/sequel_helper'
+require 'new_relic/agent/datastores/metric_helper'
 
 module Sequel
 
@@ -30,75 +31,46 @@ module Sequel
   # `disable_activerecord_instrumentation` setting.
   #
   module NewRelicInstrumentation
-    include NewRelic::Agent::MethodTracer,
-            NewRelic::Agent::Instrumentation::ActiveRecordHelper
-
 
     # Instrument all queries that go through #execute_query.
     def log_yield(sql, args=nil) #THREAD_LOCAL_ACCESS
-      state = NewRelic::Agent::TransactionState.tl_get
-      return super unless state.is_execution_traced?
-
-      t0 = Time.now
-      rval = super
-      t1 = Time.now
-
-      begin
-        duration = t1 - t0
-        record_metrics(sql, args, duration)
-        notice_sql(state, sql, args, t0, t1)
-      rescue => err
-        NewRelic::Agent.logger.debug "while recording metrics for Sequel", err
+      rval = nil
+      product = NewRelic::Agent::Instrumentation::SequelHelper.product_name_from_adapter(self.class.adapter_scheme)
+      metrics = NewRelic::Agent::Datastores::MetricHelper.metrics_from_sql(product, sql)
+      scoped_metric = metrics.first
+
+      NewRelic::Agent::MethodTracer.trace_execution_scoped(metrics) do
+        t0 = Time.now
+        begin
+          rval = super
+        rescue => err
+          NewRelic::Agent.logger.debug "while recording metrics for Sequel", err
+        ensure
+          notice_sql(sql, scoped_metric, args, t0, Time.now)
+        end
       end
 
       return rval
     end
 
-    # Record metrics for the specified +sql+ and +args+ using the specified
-    # +duration+.
-    def record_metrics(sql, args, duration) #THREAD_LOCAL_ACCESS
-      primary_metric = primary_metric_for(sql, args)
-      engine         = NewRelic::Agent.instance.stats_engine
-
-      metrics = rollup_metrics_for(primary_metric)
-      metrics << remote_service_metric(*self.opts.values_at(:adapter, :host)) if self.opts.key?(:adapter)
-
-      engine.tl_record_scoped_and_unscoped_metrics(primary_metric, metrics, duration)
-    end
-
     THREAD_SAFE_CONNECTION_POOL_CLASSES = [
-      (defined?(::Sequel::ThreadedConnectionPool) && ::Sequel::ThreadedConnectionPool),
-    ].compact.freeze
+      (defined?(::Sequel::ThreadedConnectionPool) && ::Sequel::ThreadedConnectionPool)
+    ].freeze
 
-    # Record the given +sql+ within a new frame, using the given +start+ and
-    # +finish+ times.
-    def notice_sql(state, sql, args, start, finish)
-      metric   = primary_metric_for(sql, args)
-      agent    = NewRelic::Agent.instance
+    def notice_sql(sql, metric_name, args, start, finish)
+      state    = NewRelic::Agent::TransactionState.tl_get
       duration = finish - start
-      stack    = state.traced_method_stack
 
-      begin
-        frame = stack.push_frame(state, :sequel, start)
-        explainer = Proc.new do |*|
-          if THREAD_SAFE_CONNECTION_POOL_CLASSES.include?(self.pool.class)
-            self[ sql ].explain
-          else
-            NewRelic::Agent.logger.log_once(:info, :sequel_explain_skipped, "Not running SQL explains because Sequel is not in recognized multi-threaded mode")
-            nil
-          end
+      explainer = Proc.new do |*|
+        if THREAD_SAFE_CONNECTION_POOL_CLASSES.include?(self.pool.class)
+          self[ sql ].explain
+        else
+          NewRelic::Agent.logger.log_once(:info, :sequel_explain_skipped, "Not running SQL explains because Sequel is not in recognized multi-threaded mode")
+          nil
         end
-        agent.transaction_sampler.notice_sql(sql, self.opts, duration, state, &explainer)
-        agent.sql_sampler.notice_sql(sql, metric, self.opts, duration, state, &explainer)
-      ensure
-        stack.pop_frame(state, frame, metric, finish)
       end
-    end
-
-
-    # Derive a primary database metric for the specified +sql+.
-    def primary_metric_for(sql, _)
-      return metric_for_sql(NewRelic::Helper.correctly_encoded(sql))
+      NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, self.opts, duration, state, &explainer)
+      NewRelic::Agent.instance.sql_sampler.notice_sql(sql, metric_name, self.opts, duration, state, &explainer)
     end
 
   end # module NewRelicInstrumentation

data/lib/sequel/plugins/newrelic_instrumentation.rb

@@ -5,6 +5,8 @@
 
 require 'sequel' unless defined?( Sequel )
 require 'newrelic_rpm' unless defined?( NewRelic )
+require 'new_relic/agent/instrumentation/sequel_helper'
+require 'new_relic/agent/datastores/metric_helper'
 
 module Sequel
   module Plugins
@@ -13,68 +15,49 @@ module Sequel
     module NewrelicInstrumentation
 
       # Meta-programming for creating method tracers for the Sequel::Model plugin.
-      module MethodTracer
-
-        # Make a lambda for the method body of the traced method
-        def make_tracer_method( opname, options )
-          body = Proc.new do |*args, &block|
-            classname = self.is_a?( Class ) ? self.name : self.class.name
-            metric = "ActiveRecord/%s/%s" % [ classname, opname ]
-            trace_execution_scoped( metric, options ) do
-              super( *args, &block )
-            end
-          end
-
-          return body
-        end
-
+      module MethodWrapping
         # Install a method named +method_name+ that will trace execution
-        # with a metric name derived from +metric+ (or +method_name+ if +metric+
-        # isn't specified). The +options+ hash is passed as-is though to
-        # NewRelic::Agent::MethodTracer#trace_execution_scoped; see the
-        # docs for that method for valid settings.
-        def add_method_tracer( method_name, metric=nil, options={} )
-          # Shift options hash if metric is omitted
-          if metric.is_a?( Hash )
-            options = metric
-            metric = nil
-          end
+        # with a metric name derived from +operation_name+ (or +method_name+ if +operation_name+
+        # isn't specified).
+        def wrap_sequel_method(method_name, operation_name=method_name)
+          define_method(method_name) do |*args, &block|
+            klass = self.is_a?(Class) ? self : self.class
 
-          metric ||= method_name.to_s
+            product = NewRelic::Agent::Instrumentation::SequelHelper.product_name_from_adapter(db.adapter_scheme)
+            metrics = ::NewRelic::Agent::Datastores::MetricHelper.metrics_for(product, operation_name, klass.name)
 
-          body = make_tracer_method( metric, options )
-          define_method( method_name, &body )
+            NewRelic::Agent::MethodTracer.trace_execution_scoped(metrics) do
+              NewRelic::Agent.disable_all_tracing { super(*args, &block) }
+            end
+          end
         end
 
       end # module MethodTracer
 
-
       # Methods to be added to Sequel::Model instances.
       module InstanceMethods
-        include NewRelic::Agent::MethodTracer
-        extend Sequel::Plugins::NewrelicInstrumentation::MethodTracer
+        extend Sequel::Plugins::NewrelicInstrumentation::MethodWrapping
 
-        add_method_tracer :delete
-        add_method_tracer :destroy
-        add_method_tracer :update
-        add_method_tracer :update_all
-        add_method_tracer :update_except
-        add_method_tracer :update_fields
-        add_method_tracer :update_only
-        add_method_tracer :save
+        wrap_sequel_method :delete
+        wrap_sequel_method :destroy
+        wrap_sequel_method :update
+        wrap_sequel_method :update_all
+        wrap_sequel_method :update_except
+        wrap_sequel_method :update_fields
+        wrap_sequel_method :update_only
+        wrap_sequel_method :save
 
       end # module InstanceMethods
 
 
       # Methods to be added to Sequel::Model classes.
       module ClassMethods
-        include NewRelic::Agent::MethodTracer
-        extend Sequel::Plugins::NewrelicInstrumentation::MethodTracer
+        extend Sequel::Plugins::NewrelicInstrumentation::MethodWrapping
 
-        add_method_tracer :[], :get
-        add_method_tracer :all
-        add_method_tracer :first
-        add_method_tracer :create
+        wrap_sequel_method :[], "get"
+        wrap_sequel_method :all
+        wrap_sequel_method :first
+        wrap_sequel_method :create
       end # module ClassMethods
 
     end # module NewRelicInstrumentation

data/newrelic_rpm.gemspec

@@ -70,11 +70,4 @@ EOS
     s.add_development_dependency 'rubysl'
     s.add_development_dependency 'racc'
   end
-
-  # Only sign with our private key if you can find it
-  signing_key_path = File.expand_path('~/.ssh/newrelic_rpm-private_key.pem')
-  if File.exists?(signing_key_path)
-    s.signing_key   = signing_key_path
-    s.cert_chain    = ['gem-public_cert.pem']
-  end
 end

data/test/agent_helper.rb

@@ -156,9 +156,9 @@ def assert_metrics_recorded(expected)
   expected = _normalize_metric_expectations(expected)
   expected.each do |specish, expected_attrs|
     expected_spec = metric_spec_from_specish(specish)
-    actual_stats = NewRelic::Agent.instance.stats_engine.lookup_stats(*Array(specish))
+    actual_stats = NewRelic::Agent.instance.stats_engine.to_h[expected_spec]
     if !actual_stats
-      all_specs = NewRelic::Agent.instance.stats_engine.metric_specs.sort
+      all_specs = NewRelic::Agent.instance.stats_engine.to_h.keys.sort
       matches = all_specs.select { |spec| spec.name == expected_spec.name }
       matches.map! { |m| "  #{m.inspect}" }
 
@@ -187,7 +187,7 @@ def assert_metrics_recorded_exclusive(expected, options={})
   expected = _normalize_metric_expectations(expected)
   assert_metrics_recorded(expected)
 
-  recorded_metrics = NewRelic::Agent.instance.stats_engine.metric_specs
+  recorded_metrics = NewRelic::Agent.instance.stats_engine.to_h.keys
 
   if options[:filter]
     recorded_metrics = recorded_metrics.select { |m| m.name.match(options[:filter]) }
@@ -209,7 +209,7 @@ def assert_metrics_not_recorded(not_expected)
   found_but_not_expected = []
   not_expected.each do |specish, _|
     spec = metric_spec_from_specish(specish)
-    if NewRelic::Agent.instance.stats_engine.lookup_stats(*Array(specish))
+    if NewRelic::Agent.instance.stats_engine.to_h[spec]
       found_but_not_expected << spec
     end
   end
@@ -220,7 +220,7 @@ alias :refute_metrics_recorded :assert_metrics_not_recorded
 
 def assert_no_metrics_match(regex)
   matching_metrics = []
-  NewRelic::Agent.instance.stats_engine.metrics.each do |metric|
+  NewRelic::Agent.instance.stats_engine.to_h.keys.map(&:to_s).each do |metric|
     matching_metrics << metric if metric.match regex
   end
 
@@ -327,6 +327,12 @@ def last_transaction_trace_request_params
   last_transaction_trace.params[:request_params]
 end
 
+def find_sql_trace(metric_name)
+  NewRelic::Agent.agent.sql_sampler.sql_traces.values.detect do |trace|
+    trace.database_metric_name == metric_name
+  end
+end
+
 def last_sql_trace
   NewRelic::Agent.agent.sql_sampler.sql_traces.values.last
 end
@@ -417,21 +423,29 @@ def with_transaction_renaming_rules(rule_specs)
   end
 end
 
+# Need to guard against double-installing this patch because in 1.8.x the same
+# file can be required multiple times under different non-canonicalized paths.
+unless Time.respond_to?(:__original_now)
+  Time.instance_eval do
+    class << self
+      attr_accessor :__frozen_now
+      alias_method :__original_now, :now
 
-def freeze_time(now=Time.now)
-  if block_given?
-    begin
-      Time.stubs(:now).returns(now)
-      yield now
-    ensure
-      Time.unstub(:now)
+      def now
+        __frozen_now || __original_now
+      end
     end
-  else
-    Time.stubs(:now).returns(now)
-    now
   end
 end
 
+def freeze_time(now=Time.now)
+  Time.__frozen_now = now
+end
+
+def unfreeze_time
+  Time.__frozen_now = nil
+end
+
 def advance_time(seconds)
   freeze_time(Time.now + seconds)
 end
@@ -508,7 +522,12 @@ def wait_for_backtrace_service_poll(opts={})
   until opts[:service].worker_loop.iterations > opts[:iterations]
     sleep(0.01)
     if Time.now > deadline
-      raise "Timed out waiting #{opts[:timeout]} s for backtrace service poll"
+      raise "Timed out waiting #{opts[:timeout]} s for backtrace service poll\n" +
+            "Worker loop ran for #{opts[:service].worker_loop.iterations} iterations\n\n" +
+            Thread.list.map { |t|
+              "#{t.to_s}: newrelic_label: #{t[:newrelic_label].inspect}\n\n" +
+              (t.backtrace || []).join("\n\t")
+            }.join("\n\n")
     end
   end
 end

data/test/environments/rails31/Gemfile

@@ -1,6 +1,7 @@
 source 'https://rubygems.org'
 
 gem 'rails', '~>3.1.12'
+gem 'i18n', '0.6.11'
 
 gem 'rake', '~>10.1.1'
 gem 'minitest', '~>4.7.5'

data/test/environments/rails32/Gemfile

@@ -1,6 +1,7 @@
 source 'https://rubygems.org'
 
 gem 'rails', '~>3.2.20'
+gem 'i18n', '0.6.11'
 
 gem 'rake', '~>10.1.1'
 gem 'minitest', '~>4.7.5'

data/test/helpers/mongo_metric_builder.rb

@@ -7,11 +7,10 @@ require 'new_relic/agent/datastores/mongo/metric_translator'
 module NewRelic
   module TestHelpers
     module MongoMetricBuilder
-      def build_test_metrics(name, request_type = :web)
+      def build_test_metrics(name)
         NewRelic::Agent::Datastores::Mongo::MetricTranslator.build_metrics(
           name,
-          @collection_name,
-          request_type
+          @collection_name
         )
       end
 

data/test/multiverse/lib/multiverse/output_collector.rb

@@ -17,7 +17,7 @@ module Multiverse
     @buffer_lock = Mutex.new
 
     def self.failing_output
-      @failing ||= []
+      @failing_output ||= []
     end
 
     def self.buffer(suite, env)
@@ -30,8 +30,11 @@ module Multiverse
     end
 
     def self.failed(suite, env)
-      @failing ||= []
-      @failing << buffer(suite, env) + "\n"
+      @failing_suites ||= []
+      @failing_suites << [suite, env]
+
+      @failing_output ||= []
+      @failing_output << buffer(suite, env) + "\n"
     end
 
     def self.write(suite, env, msg)
@@ -47,15 +50,27 @@ module Multiverse
       if failing_output.empty?
         output(green("There were no test failures"))
       else
-        output(
-          red("*" * 80),
-          red("There were failures in #{failing_output.size} test suites"),
-          red("Here is their output"),
-          red("*" * 80),
-          *failing_output)
+        to_output = failing_output_header + failing_output + failing_output_footer
+        output(*to_output)
       end
     end
 
+    def self.failing_output_header
+      [red("*" * 80),
+        red("Repeating failed test output"),
+        red("*" * 80),
+        ""]
+    end
+
+    def self.failing_output_footer
+      ["",
+        red("*" * 80),
+        red("There were failures in #{failing_output.size} test suites"),
+        "",
+        @failing_suites.map { |suite, env| red("#{suite} failed in env #{env}") },
+        red("*" * 80)]
+    end
+
     # Because the various environments potentially run in separate threads to
     # start their processes, make sure we don't blatantly interleave output.
     def self.output(*args)