newrelic_rpm 3.8.1.221 → 3.9.0.229

data/lib/new_relic/transaction_sample/composite_segment.rb

@@ -12,7 +12,7 @@ module NewRelic
 
       def initialize(segments)
         summary = SummarySegment.new(segments.first)
-        super summary.entry_timestamp, "Repeating pattern (#{segments.length} repeats)", nil
+        super summary.entry_timestamp, "Repeating pattern (#{segments.length} repeats)"
 
         summary.end_trace(segments.last.exit_timestamp)
 

data/lib/new_relic/transaction_sample/segment.rb

@@ -12,14 +12,19 @@ module NewRelic
       # have a timestamp.
       attr_reader :exit_timestamp
       attr_reader :parent_segment
+
+      # This is only used from developer mode and rpm_site.
+      # No new clients should be added.
       attr_reader :segment_id
 
       attr_accessor :metric_name
 
-      def initialize(timestamp, metric_name, segment_id)
+      UNKNOWN_SEGMENT_NAME = '<unknown>'.freeze
+
+      def initialize(timestamp, metric_name, segment_id=nil)
         @entry_timestamp = timestamp
-        @metric_name = metric_name || '<unknown>'
-        @segment_id = segment_id || object_id
+        @metric_name     = metric_name || UNKNOWN_SEGMENT_NAME
+        @segment_id      = segment_id  || object_id
       end
 
       # sets the final timestamp on a segment to indicate the exit
@@ -55,6 +60,7 @@ module NewRelic
       def path_string
         "#{metric_name}[#{called_segments.collect {|segment| segment.path_string }.join('')}]"
       end
+
       def to_s_compact
         str = ""
         str << metric_name
@@ -63,6 +69,7 @@ module NewRelic
         end
         str
       end
+
       def to_debug_str(depth)
         tab = "  " * depth
         s = tab.clone
@@ -155,8 +162,9 @@ module NewRelic
         summary.current_nest_count -= 1 if summary
       end
 
+      # This is only for use by developer mode
       def find_segment(id)
-        return self if @segment_id == id
+        return self if segment_id == id
         called_segments.each do |segment|
           found = segment.find_segment(id)
           return found if found

data/lib/new_relic/transaction_sample/summary_segment.rb

@@ -8,7 +8,7 @@ module NewRelic
   class TransactionSample
     class SummarySegment < Segment
       def initialize(segment)
-        super segment.entry_timestamp, segment.metric_name, nil
+        super segment.entry_timestamp, segment.metric_name
 
         add_segments segment.called_segments
 

data/lib/new_relic/version.rb

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

data/lib/newrelic_rpm.rb

@@ -32,7 +32,7 @@ if defined?(Merb) && defined?(Merb::BootLoader)
       end
     end
   end
-elsif defined? Rails
+elsif defined?(Rails::VERSION)
   if Rails::VERSION::MAJOR.to_i >= 3
     module NewRelic
       class Railtie < Rails::Railtie

data/lib/sequel/extensions/newrelic_instrumentation.rb

@@ -35,8 +35,9 @@ module Sequel
 
 
     # Instrument all queries that go through #execute_query.
-    def log_yield( sql, args=nil )
-      return super unless NewRelic::Agent.is_execution_traced?
+    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
@@ -44,8 +45,8 @@ module Sequel
 
       begin
         duration = t1 - t0
-        record_metrics( sql, args, duration )
-        notice_sql( sql, args, t0, t1 )
+        record_metrics(sql, args, duration)
+        notice_sql(state, sql, args, t0, t1)
       rescue => err
         NewRelic::Agent.logger.debug "while recording metrics for Sequel", err
       end
@@ -55,16 +56,14 @@ module Sequel
 
     # Record metrics for the specified +sql+ and +args+ using the specified
     # +duration+.
-    def record_metrics( sql, args, duration)
-      primary_metric = primary_metric_for( sql, args )
+    def record_metrics(sql, args, duration) #THREAD_LOCAL_ACCESS
+      primary_metric = primary_metric_for(sql, args)
       engine         = NewRelic::Agent.instance.stats_engine
 
-      engine.record_metrics( primary_metric, duration, :scoped => true )
+      metrics = rollup_metrics_for(primary_metric)
+      metrics << remote_service_metric(*self.opts.values_at(:adapter, :host)) if self.opts.key?(:adapter)
 
-      metrics = rollup_metrics_for( primary_metric )
-      metrics << remote_service_metric( *self.opts.values_at(:adapter, :host) ) if self.opts.key?(:adapter)
-
-      engine.record_metrics( metrics, duration, :scoped => false )
+      engine.tl_record_scoped_and_unscoped_metrics(primary_metric, metrics, duration)
     end
 
     THREAD_SAFE_CONNECTION_POOL_CLASSES = [
@@ -73,13 +72,14 @@ module Sequel
 
     # Record the given +sql+ within a new frame, using the given +start+ and
     # +finish+ times.
-    def notice_sql( sql, args, start, finish )
-      metric   = primary_metric_for( sql, args )
+    def notice_sql(state, sql, args, start, finish)
+      metric   = primary_metric_for(sql, args)
       agent    = NewRelic::Agent.instance
       duration = finish - start
+      stack    = state.traced_method_stack
 
       begin
-        frame = NewRelic::Agent::TracedMethodStack.push_frame( :sequel, start )
+        frame = stack.push_frame(state, :sequel, start)
         explainer = Proc.new do |*|
           if THREAD_SAFE_CONNECTION_POOL_CLASSES.include?(self.pool.class)
             self[ sql ].explain
@@ -88,22 +88,22 @@ module Sequel
             nil
           end
         end
-        agent.transaction_sampler.notice_sql( sql, self.opts, duration, &explainer )
-        agent.sql_sampler.notice_sql( sql, metric, self.opts, duration, &explainer )
+        agent.transaction_sampler.notice_sql(sql, self.opts, duration, state, &explainer)
+        agent.sql_sampler.notice_sql(sql, metric, self.opts, duration, state, &explainer)
       ensure
-        NewRelic::Agent::TracedMethodStack.pop_frame( frame, metric, finish )
+        stack.pop_frame(state, frame, metric, finish)
       end
     end
 
 
     # Derive a primary database metric for the specified +sql+.
-    def primary_metric_for( sql, _ )
+    def primary_metric_for(sql, _)
       return metric_for_sql(NewRelic::Helper.correctly_encoded(sql))
     end
 
   end # module NewRelicInstrumentation
 
   NewRelic::Agent.logger.debug "Registering the :newrelic_instrumentation extension."
-  Database.register_extension( :newrelic_instrumentation, NewRelicInstrumentation )
+  Database.register_extension(:newrelic_instrumentation, NewRelicInstrumentation)
 
 end # module Sequel

data/lib/tasks/tests.rake

@@ -4,7 +4,25 @@ rescue LoadError => e
 end
 
 if defined? Rake::TestTask
-  namespace :test do
+  namespace :test do |t|
+    def look_for_seed(tasks)
+      matches = tasks.map { |t| /(seed=.*?)[,\]]/.match(t) }.compact
+      if matches.any?
+        matches.first[1]
+      else
+        nil
+      end
+    end
+
+    tasks = Rake.application.top_level_tasks
+    ENV["TESTOPTS"] ||= ""
+    if tasks.any? { |t| t.include?("verbose")}
+      ENV["TESTOPTS"] += " -v"
+    end
+    if seed = look_for_seed(tasks)
+      ENV["TESTOPTS"] += " --" + seed
+    end
+
     agent_home = File.expand_path(File.join(File.dirname(__FILE__),'..','..'))
 
     Rake::TestTask.new(:newrelic) do |t|
@@ -13,5 +31,6 @@ if defined? Rake::TestTask
       t.pattern = "#{agent_home}/test/new_relic/**/*_test.rb"
       t.verbose = true
     end
+
   end
 end

data/lib/tasks/versions.html.erb

@@ -2,20 +2,16 @@
 <table>
   <thead>
     <th>Name</th>
-    <% unless suppress_versions %>
     <th>Supported</th>
     <th>Deprecated</th>
     <th>Experimental</th>
-    <% end %>
   </thead>
   <% for version in versions %>
     <tr>
       <td><b><%= version.name %></b></td>
-      <% unless suppress_versions %>
       <td><%= version_list(version.supported) %></td>
       <td><%= version_list(version.deprecated) %></td>
       <td><%= version_list(version.experimental) %></td>
-      <% end %>
     </tr>
     <% if version.notes %>
     <tr>

data/lib/tasks/versions.rake

@@ -12,7 +12,8 @@ namespace :newrelic do
 
     def versions_for_type(type)
       NewRelic::Agent::SUPPORTED_VERSIONS.
-        select {|_,v| v[:type] == type}.
+        select  {|key, values| values[:type] == type}.
+        sort_by {|key, values| (values[:name] || key).to_s }.
         map    do |key,values|
           VersionStruct.new(
             values[:name] || key,
@@ -30,7 +31,7 @@ namespace :newrelic do
       ERB.new(template)
     end
 
-    def write_versions(title, type, erb, suppress_versions = false)
+    def write_versions(title, type, erb)
       anchor = title.downcase.gsub(" ", "_")
       versions = versions_for_type(type)
       puts erb.result(binding).gsub(/^ *$/, '')
@@ -47,6 +48,6 @@ namespace :newrelic do
     write_versions("Database",        :database, erb)
     write_versions("Background Jobs", :background, erb)
     write_versions("HTTP Clients",    :http, erb)
-    write_versions("Other",           :other, erb, true)
+    write_versions("Other",           :other, erb)
   end
 end

data/newrelic.yml

@@ -1,7 +1,7 @@
 #
-# This file configures the New Relic Agent.  New Relic monitors
-# Ruby, Java, .NET, PHP, and Python applications with deep visibility and low overhead.
-# For more information, visit www.newrelic.com.
+# This file configures the New Relic Agent.  New Relic monitors Ruby, Java,
+# .NET, PHP, Python and Node applications with deep visibility and low
+# overhead.  For more information, visit www.newrelic.com.
 #
 # Generated <%= Time.now.strftime('%B %d, %Y') %>, for version <%= NewRelic::VERSION::STRING %>
 #
@@ -160,11 +160,6 @@ common: &default_settings
     # product levels.
     enabled: true
 
-    # Rails Only - tells error collector whether or not to capture a
-    # source snippet around the place of the error when errors are View
-    # related.
-    capture_source: true
-
     # To stop specific errors from reporting to New Relic, set this property
     # to comma-separated values.  Default is to ignore routing errors,
     # which are how 404's get triggered.
@@ -197,10 +192,7 @@ development:
   # executed since starting the mongrel.
   # NOTE: There is substantial overhead when running in developer mode.
   # Do not use for production or load testing.
-  developer_mode: false
-
-  # Enable textmate links
-  # textmate: true
+  developer_mode: true
 
 test:
   <<: *default_settings

data/newrelic_rpm.gemspec

@@ -46,7 +46,7 @@ EOS
   s.add_development_dependency 'mocha', '~> 0.13.0'
   s.add_development_dependency 'yard'
   s.add_development_dependency 'rails', '~> 3.2.13'
-  s.add_development_dependency 'pry'
+  s.add_development_dependency 'pry', '~> 0.9.12'
 #  s.add_development_dependency 'pry-nav'
   s.add_development_dependency 'guard', '~> 1.8.3' # Guard 2.0 is Ruby 1.9 only
   s.add_development_dependency 'guard-minitest'

data/test/agent_helper.rb

@@ -28,7 +28,7 @@ end
 
 def assert_has_error(error_class)
   assert \
-    NewRelic::Agent.instance.error_collector.errors.find {|e| e.exception_class_constant == error_class} != nil, \
+    NewRelic::Agent.instance.error_collector.errors.find {|e| e.exception_class_name == error_class.name} != nil, \
     "Didn't find error of class #{error_class}"
 end
 
@@ -90,6 +90,32 @@ def _normalize_metric_expectations(expectations)
   end
 end
 
+def dump_stats(stats)
+  str =  "  Call count:           #{stats.call_count}\n"
+  str << "  Total call time:      #{stats.total_call_time}\n"
+  str << "  Total exclusive time: #{stats.total_exclusive_time}\n"
+  str << "  Min call time:        #{stats.min_call_time}\n"
+  str << "  Max call time:        #{stats.max_call_time}\n"
+  str << "  Sum of squares:       #{stats.sum_of_squares}\n"
+  str << "  Apdex S:              #{stats.apdex_s}\n"
+  str << "  Apdex T:              #{stats.apdex_t}\n"
+  str << "  Apdex F:              #{stats.apdex_f}\n"
+  str
+end
+
+def assert_stats_has_values(stats, expected_spec, expected_attrs)
+  expected_attrs.each do |attr, expected_value|
+    actual_value = stats.send(attr)
+    if attr == :call_count
+      assert_equal(expected_value, actual_value,
+        "Expected #{attr} for #{expected_spec} to be #{expected_value}, got #{actual_value}.\nActual stats:\n#{dump_stats(stats)}")
+    else
+      assert_in_delta(expected_value, actual_value, 0.0001,
+        "Expected #{attr} for #{expected_spec} to be ~#{expected_value}, got #{actual_value}.\nActual stats:\n#{dump_stats(stats)}")
+    end
+  end
+end
+
 def assert_metrics_recorded(expected)
   expected = _normalize_metric_expectations(expected)
   expected.each do |specish, expected_attrs|
@@ -99,39 +125,47 @@ def assert_metrics_recorded(expected)
       all_specs = NewRelic::Agent.instance.stats_engine.metric_specs.sort
       matches = all_specs.select { |spec| spec.name == expected_spec.name }
       matches.map! { |m| "  #{m.inspect}" }
+
       msg = "Did not find stats for spec #{expected_spec.inspect}."
       msg += "\nDid find specs: [\n#{matches.join(",\n")}\n]" unless matches.empty?
-
-      msg += "\nAll specs in there were: [\n#{all_specs.map do |s|
-        "  #{s.name} (#{s.scope.empty? ? '<unscoped>' : s.scope})"
-      end.join(",\n")}\n]"
+      msg += "\nAll specs in there were: #{format_metric_spec_list(all_specs)}"
 
       assert(actual_stats, msg)
     end
-    expected_attrs.each do |attr, expected_value|
-      actual_value = actual_stats.send(attr)
-      if attr == :call_count
-        assert_equal(expected_value, actual_value,
-          "Expected #{attr} for #{expected_spec} to be #{expected_value}, got #{actual_value}")
-      else
-        assert_in_delta(expected_value, actual_value, 0.0001,
-          "Expected #{attr} for #{expected_spec} to be ~#{expected_value}, got #{actual_value}")
-      end
-    end
+    assert_stats_has_values(actual_stats, expected_spec, expected_attrs)
   end
 end
 
+# Use this to assert that *only* the given set of metrics has been recorded.
+#
+# If you want to scope the search for unexpected metrics to a particular
+# namespace (e.g. metrics matching 'Controller/'), pass a Regex for the
+# :filter option. Only metrics matching the regex will be searched when looking
+# for unexpected metrics.
+#
+# If you want to *allow* unexpected metrics matching certain patterns, use
+# the :ignore_filter option. This will allow you to specify a Regex that
+# whitelists broad swathes of metric territory (e.g. 'Supportability/').
+#
 def assert_metrics_recorded_exclusive(expected, options={})
   expected = _normalize_metric_expectations(expected)
   assert_metrics_recorded(expected)
-  recorded_metrics = NewRelic::Agent.instance.stats_engine.metrics
+
+  recorded_metrics = NewRelic::Agent.instance.stats_engine.metric_specs
+
   if options[:filter]
-    recorded_metrics = recorded_metrics.select { |m| m.match(options[:filter]) }
+    recorded_metrics = recorded_metrics.select { |m| m.name.match(options[:filter]) }
   end
-  expected_metrics = expected.keys.map { |s| metric_spec_from_specish(s).to_s }
-  unexpected_metrics = recorded_metrics.select { |m| m !~ /GC\/Transaction/ }
-  unexpected_metrics -= expected_metrics
-  assert_equal(0, unexpected_metrics.size, "Found unexpected metrics: [#{unexpected_metrics.join(', ')}]")
+  if options[:ignore_filter]
+    recorded_metrics.reject! { |m| m.name.match(options[:ignore_filter]) }
+  end
+
+  expected_metrics   = expected.keys.map { |s| metric_spec_from_specish(s) }
+
+  unexpected_metrics = recorded_metrics - expected_metrics
+  unexpected_metrics.reject! { |m| m.name =~ /GC\/Transaction/ }
+
+  assert_equal(0, unexpected_metrics.size, "Found unexpected metrics: #{format_metric_spec_list(unexpected_metrics)}")
 end
 
 def assert_metrics_not_recorded(not_expected)
@@ -143,7 +177,14 @@ def assert_metrics_not_recorded(not_expected)
       found_but_not_expected << spec
     end
   end
-  assert_equal([], found_but_not_expected, "Found unexpected metrics: [#{found_but_not_expected.join(', ')}]")
+  assert_equal([], found_but_not_expected, "Found unexpected metrics: #{format_metric_spec_list(found_but_not_expected)}")
+end
+
+def format_metric_spec_list(specs)
+  spec_strings = specs.map do |spec|
+    "#{spec.name} (#{spec.scope.empty? ? '<unscoped>' : spec.scope})"
+  end
+  "[\n  #{spec_strings.join(",\n  ")}\n]"
 end
 
 def assert_truthy(expected, msg = nil)
@@ -167,45 +208,46 @@ unless defined?(refute)
 end
 
 # Mock up a transaction for testing purposes, optionally specifying a name and
-# transaction type. The given block will be executed within the context of the
+# transaction category. The given block will be executed within the context of the
 # dummy transaction.
 #
 # Examples:
 #
-# With default name ('dummy') and type (:other):
+# With default name ('dummy') and category (:other):
 #   in_transaction { ... }
 #
-# With an explicit transaction name and default type:
+# With an explicit transaction name and default category:
 #   in_transaction('foobar') { ... }
 #
-# With default name and explicit type:
-#   in_transaction(:type => :controller) { ... }
+# With default name and explicit category:
+#   in_transaction(:category => :controller) { ... }
 #
-# With a transaction name plus type:
-#   in_transaction('foobar', :type => :controller) { ... }
+# With a transaction name plus category:
+#   in_transaction('foobar', :category => :controller) { ... }
 #
 def in_transaction(*args)
   opts = (args.last && args.last.is_a?(Hash)) ? args.pop : {}
   opts[:transaction_name] = args.first || 'dummy'
-  transaction_type = (opts && opts.delete(:type)) || :other
+  category = (opts && opts.delete(:category)) || :other
+  state = NewRelic::Agent::TransactionState.tl_get
 
-  NewRelic::Agent::Transaction.start(transaction_type, opts)
+  NewRelic::Agent::Transaction.start(state, category, opts)
 
   val = nil
 
   begin
-    val = yield NewRelic::Agent::Transaction.current
+    val = yield state.current_transaction
   ensure
-    NewRelic::Agent::Transaction.stop()
+    NewRelic::Agent::Transaction.stop(state)
   end
 
   val
 end
 
-# Convenience wrapper around in_transaction that sets the type so that it
+# 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')
-  in_transaction(name, :type => :controller) do
+  in_transaction(name, :category => :controller) do
     yield
   end
 end
@@ -214,7 +256,7 @@ def find_last_transaction_segment(transaction_sample=nil)
   if transaction_sample
     root_segment = transaction_sample.root_segment
   else
-    builder = NewRelic::Agent.agent.transaction_sampler.builder
+    builder = NewRelic::Agent.agent.transaction_sampler.tl_builder
     root_segment = builder.current_segment
   end
 
@@ -224,15 +266,49 @@ def find_last_transaction_segment(transaction_sample=nil)
   return last_segment
 end
 
-def find_segment_by_name(transaction_sample, name)
-  first_segment = nil
-  transaction_sample.root_segment.each_segment do |s|
-    if s.metric_name == name
-      first_segment = s
-      break
+def collect_segment_names(transaction_sample)
+  names = []
+
+  transaction_sample.root_segment.each_segment do |segment|
+    names << segment.metric_name
+  end
+
+  names
+end
+
+def find_segment_with_name(transaction_sample, name)
+  transaction_sample.root_segment.each_segment do |segment|
+    if segment.metric_name == name
+      return segment
+    end
+  end
+
+  nil
+end
+
+def find_segment_with_name_matching(transaction_sample, regex)
+  transaction_sample.root_segment.each_segment do |segment|
+    if segment.metric_name.match regex
+      return segment
     end
   end
-  first_segment
+
+  nil
+end
+
+def find_all_segments_with_name_matching(transaction_sample, regexes)
+  regexes = [regexes].flatten
+  matching_segments = []
+
+  transaction_sample.root_segment.each_segment do |segment|
+    regexes.each do |regex|
+      if segment.metric_name.match regex
+        matching_segments << segment
+      end
+    end
+  end
+
+  matching_segments
 end
 
 def with_config(config_hash, opts={})
@@ -242,7 +318,7 @@ def with_config(config_hash, opts={})
   else
     config = NewRelic::Agent::Configuration::DottedHash.new(config_hash)
   end
-  NewRelic::Agent.config.apply_config(config, opts[:level])
+  NewRelic::Agent.config.add_config_for_testing(config, opts[:level])
   begin
     yield
   ensure
@@ -355,3 +431,29 @@ def with_array_logger(level=:info)
 ensure
   NewRelic::Agent.logger = orig_logger
 end
+
+def with_environment(env)
+  old_env = {}
+  env.each do |key, val|
+    old_env[key] = ENV[key]
+    ENV[key]     = val.to_s
+  end
+  begin
+    yield
+  ensure
+    old_env.each { |key, old_val| ENV[key] = old_val }
+  end
+end
+
+def with_ignore_error_filter(filter, &blk)
+  original_filter = NewRelic::Agent.ignore_error_filter
+  NewRelic::Agent.ignore_error_filter(&filter)
+
+  yield
+ensure
+  if original_filter.nil?
+    NewRelic::Agent.instance.error_collector.clear_ignore_error_filter
+  else
+    NewRelic::Agent.ignore_error_filter(&original_filter)
+  end
+end