newrelic_rpm 2.13.2 → 2.13.3.beta

data/CHANGELOG

@@ -1,3 +1,21 @@
+v2.13.3
+  * Dalli instrumentation from Mike Perham (thanks Mike)
+  * Datamapper instrumentation from Jordan Ritter (thanks Jordan)
+  * Apdex now defaults to 0.5
+    !!! Please be aware that if you are not setting an apdex, 
+    !!! this will cause a change in the apparent performance of your app.
+  * Make metric hashes threadsafe (fixes problems sending metrics in Jruby
+    threaded code)
+  * Delete obsolete links to metric docs in developer mode
+  * Detect gems when using Bundler
+  * Fix newrelic_ignore in Rails 3
+  * Break metric parser into a seperate vendored gem
+  * When using Unicorn, preload_app: true is recommended to get proper
+    after_fork behavior.
+
+v2.13.2
+  * Remove a puts. Yes, a whole release for a puts.
+
 v2.13.1
   * Add missing require in rails 3 framework control
 

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008-2009 New Relic, Inc.  All rights reserved.
+Copyright (c) 2008-2010 New Relic, Inc.  All rights reserved.
 
 Certain inventions disclosed in this file may be claimed within
 patents owned or patent applications filed by New Relic, Inc. or third

data/README.rdoc

@@ -5,7 +5,7 @@ New Relic, Inc (http://www.newrelic.com).  RPM provides you with deep
 information about the performance of your Ruby on Rails or Merb
 application as it runs in production. The New Relic Agent is
 dual-purposed as a either a Rails plugin or a Gem, hosted on
-github[http://github.com/newrelic/rpm/tree/master] and Rubyforge.
+github[http://github.com/newrelic/rpm/tree/master].
 
 The New Relic Agent runs in one of two modes:
 
@@ -60,12 +60,17 @@ and then in a <tt>~/.newrelic</tt> directory
 
 === Rails Installation
 
-You can install the agent as a plug-in or a Gem.  To install the agent
-as a Rails plug-in, do the following:
+You can install the agent as a Gem:
 
-    script/plugin install http://newrelic.rubyforge.org/svn/newrelic_rpm
+For Bundler:
+
+Add the following line to your Gemfile:
+
+    gem 'newrelic_rpm'
+
+For Rails 2.x without Bundler:
    
-If using the Agent as a gem, edit +environment.rb+ and add to the initalizer block:
+edit +environment.rb+ and add to the initalizer block:
 
     config.gem "newrelic_rpm" 
 

data/lib/conditional_vendored_metric_parser.rb

@@ -0,0 +1,5 @@
+unless defined?(NewRelic) && defined?(NewRelic::MetricParser)
+  vendored_metric_parser = File.expand_path('../../vendor/gems/metric_parser-0.1.0.pre1/lib/', __FILE__)
+  $:.unshift vendored_metric_parser unless $:.include?(vendored_metric_parser)
+  require 'metric_parser'
+end

data/lib/new_relic/agent.rb

@@ -63,7 +63,6 @@ module NewRelic
     require 'new_relic/metrics'
     require 'new_relic/metric_spec'
     require 'new_relic/metric_data'
-    require 'new_relic/metric_parser'
     require 'new_relic/collection_helper'
     require 'new_relic/transaction_analysis'
     require 'new_relic/transaction_sample'

data/lib/new_relic/agent/agent.rb

@@ -67,7 +67,7 @@ module NewRelic
           metric = options['metric']
           metric ||= options['uri'] # normalize this with url rules
           raise "metric or uri arguments required" unless metric
-          metric_info = NewRelic::MetricParser.for_metric_named(metric)
+          metric_info = NewRelic::MetricParser::MetricParser.for_metric_named(metric)
 
           if metric_info.is_web_transaction?
             NewRelic::Agent::Instrumentation::MetricFrame.record_apdex(metric_info, duration_seconds, duration_seconds, is_error)

data/lib/new_relic/agent/error_collector.rb

@@ -105,6 +105,8 @@ module NewRelic
         end
       end
       exception
+    rescue Exception => e
+      log.error("Error capturing an error, yodawg. #{e}")
     end
 
     # Get the errors currently queued up.  Unsent errors are left

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

@@ -1,58 +1,181 @@
+## NewRelic instrumentation for DataMapper
+#
+# Instrumenting DM has different key challenges versus AR:
+#
+#   1. The hooking of SQL logging in DM is decoupled from any knowledge of the
+#      Model#method that invoked it.  But on the positive side, the duration is
+#      already calculated for you (and it happens inside the C-based DO code, so
+#      it's faster than a Ruby equivalent).
+#
+#   2. There are a lot more entry points that need to be hooked in order to
+#      understand call flow: DM::Model (model class) vs. DM::Resource (model
+#      instance) vs. DM::Collection (collection of model instances).  And
+#      others.
+#
+#   3. Strategic Eager Loading (SEL) combined with separately-grouped
+#      lazy-loaded attributes presents a unique problem for tying resulting
+#      SEL-invoked SQL calls to their proper scope.
+#
+# NOTE: On using "Database" versus "ActiveRecord" as base metric name
+#
+#   Using "Database" as the metric name base seems to properly identify methods
+#   as being DB-related in call graphs, but certain RPM views that show
+#   aggregations of DB CPM, etc still seem to rely solely on "ActiveRecord"
+#   being the base name, thus AFAICT "Database" calls to this are lost.  (Though
+#   I haven't yet tested "Database/SQL/{find/save/destroy/all}" yet, as it seems
+#   like an intuitively good name to use.)
+#
+#   So far I think these are the rules:
+#
+#     - ActiveRecord/{find/save/destroy} populates "Database Throughput" and
+#       "Database Response Time" in the Database tab. [non-scoped]
+#
+#     - ActiveRecord/all populates the main Overview tab of DB time.  (still
+#       unsure about this one). [non-scoped]
+#
+#     These metrics are represented as :push_scope => false or included as the
+#     non-first metric in trace_execution_scoped() (docs say only first counts
+#     towards scope) so they don't show up ine normal call graph/trace.
 
-# NewRelic instrumentation for DataMapper
-# For now, we have to refer to all db metrics as "ActiveRecord"
-if defined? DataMapper
+if defined? ::DataMapper
 
-  DataMapper::Model.class_eval do
-    add_method_tracer :get, 'ActiveRecord/#{self.name}/find'
-    add_method_tracer :first, 'ActiveRecord/#{self.name}/find'
-    add_method_tracer :first_or_create, 'ActiveRecord/#{self.name}/find'
-    add_method_tracer :all, 'ActiveRecord/#{self.name}/find_all'
-  end
-  DataMapper::Resource.class_eval do
+  # DM::Model class methods
+  ::DataMapper::Model.class_eval do
 
-    @@my_sql_defined = defined? ActiveRecord::ConnectionAdapters::MysqlAdapter
-    @@postgres_defined = defined? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+    add_method_tracer :get,      'ActiveRecord/#{self.name}/get'
+    add_method_tracer :first,    'ActiveRecord/#{self.name}/first'
+    add_method_tracer :last,     'ActiveRecord/#{self.name}/last'
+    add_method_tracer :all,      'ActiveRecord/#{self.name}/all'
 
-    for method in [:query] do
-      add_method_tracer method, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/execute'
-      add_method_tracer method, 'ActiveRecord/all', :push_scope => false
-    end
-    for method in [:update, :save] do
-      add_method_tracer method, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
-      add_method_tracer method, 'ActiveRecord/save', :push_scope => false
-    end
-    add_method_tracer :destroy, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
-    add_method_tracer :destroy, 'ActiveRecord/destroy', :push_scope => false
-
-    def log_with_newrelic_instrumentation(sql, name, &block)
-      # if we aren't in a blamed context, then add one so that we can
-      # see that controllers are calling SQL directly we check
-      # scope_depth vs 2 since the controller is 1
-      if NewRelic::Agent.instance.transaction_sampler.scope_depth < 2
-        self.class.trace_method_execution "Database/DirectSQL", true, true do
-          log_with_capture_sql(sql, name, &block)
-        end
-      else
-        log_with_capture_sql(sql, name, &block)
-      end
+    add_method_tracer :create,   'ActiveRecord/#{self.name}/create'
+    add_method_tracer :create!,  'ActiveRecord/#{self.name}/create'
+    add_method_tracer :update,   'ActiveRecord/#{self.name}/update'
+    add_method_tracer :update!,  'ActiveRecord/#{self.name}/update'
+    add_method_tracer :destroy,  'ActiveRecord/#{self.name}/destroy'
+    add_method_tracer :destroy!, 'ActiveRecord/#{self.name}/destroy'
+
+    # For dm-aggregates and partial dm-ar-finders support:
+    for method in [ :aggregate, :find, :find_by_sql ] do
+      next unless method_defined? method
+      add_method_tracer(method, 'ActiveRecord/#{self.name}/' + method.to_s)
     end
 
-    def log_with_capture_sql(sql, name, &block)
-      if @@my_sql_defined && self.is_a?(ActiveRecord::ConnectionAdapters::MysqlAdapter)
-        config = @config
-      elsif @@postgres_defined && self.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
-        config = @config
-      else
-        config = nil
-      end
+  end
+
+  # DM's Model instance (Resource) methods
+  ::DataMapper::Resource.class_eval do
+
+    add_method_tracer :update,   'ActiveRecord/#{self.class.name[/[^:]*$/]}/update'
+    add_method_tracer :update!,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/update'
+    add_method_tracer :save,     'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
+    add_method_tracer :save!,    'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
+    add_method_tracer :destroy,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
+    add_method_tracer :destroy!, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
 
-      t0 = Time.now
-      result = log_without_newrelic_instrumentation(sql, name, &block)
+  end
+
+  # DM's Collection instance methods
+  ::DataMapper::Collection.class_eval do
+
+    add_method_tracer :get,       'ActiveRecord/#{self.name}/get'
+    add_method_tracer :first,     'ActiveRecord/#{self.name}/first'
+    add_method_tracer :last,      'ActiveRecord/#{self.name}/last'
+    add_method_tracer :all,       'ActiveRecord/#{self.name}/all'
+
+    add_method_tracer :lazy_load, 'ActiveRecord/#{self.name}/lazy_load'
 
-      NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, config, (Time.now - t0).to_f)
+    add_method_tracer :create,    'ActiveRecord/#{self.name}/create'
+    add_method_tracer :create!,   'ActiveRecord/#{self.name}/create'
+    add_method_tracer :update,    'ActiveRecord/#{self.name}/update'
+    add_method_tracer :update!,   'ActiveRecord/#{self.name}/update'
+    add_method_tracer :destroy,   'ActiveRecord/#{self.name}/destroy'
+    add_method_tracer :destroy!,  'ActiveRecord/#{self.name}/destroy'
 
-      result
+    # For dm-aggregates support:
+    for method in [ :aggregate ] do
+      next unless method_defined? method
+      add_method_tracer(method, 'ActiveRecord/#{self.name}/' + method.to_s)
     end
+
   end
-end
+
+  # Catch the two entry points into DM::Repository::Adapter that bypass CRUD
+  # (for when SQL is run directly).
+  ::DataMapper::Adapters::DataObjectsAdapter.class_eval do
+
+    add_method_tracer :select,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/select'
+    add_method_tracer :execute, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/execute'
+
+  end if defined? ::DataMapper::Adapters::DataObjectsAdapter
+
+  # DM::Validations overrides Model#create, but currently in a way that makes it
+  # impossible to instrument from one place.  I've got a patch pending inclusion
+  # to make it instrumentable by putting the create method inside ClassMethods.
+  # This will pick it up if/when that patch is accepted.
+  ::DataMapper::Validations::ClassMethods.class_eval do
+
+    next unless method_defined? :create
+    add_method_tracer :create,   'ActiveRecord/#{self.name}/create'
+
+  end if defined? ::DataMapper::Validations::ClassMethods
+
+  # NOTE: DM::Transaction basically calls commit() twice, so as-is it will show
+  # up in traces twice -- second time subordinate to the first's scope.  Works
+  # well enough.
+  ::DataMapper::Transaction.module_eval do
+    add_method_tracer :commit, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/commit'
+  end if defined? ::DataMapper::Transaction
+
+  module NewRelic
+    module Agent
+      module Instrumentation
+        module DataMapperInstrumentation
+
+          def self.included(klass)
+            klass.class_eval do
+              alias_method :log_without_newrelic_instrumentation, :log
+              alias_method :log, :log_with_newrelic_instrumentation
+            end
+          end
+
+          # Unlike in AR, log is called in DM after the query actually ran,
+          # complete with metrics.  Since DO has already calculated the
+          # duration, there's nothing more to measure, so just record and log.
+          #
+          # We rely on the assumption that all possible entry points have been
+          # hooked with tracers, ensuring that notice_sql attaches this SQL to
+          # the proper call scope.
+          def log_with_newrelic_instrumentation(msg)
+            return unless NewRelic::Agent.is_execution_traced?
+            return unless operation = case msg.query
+              when /^\s*select/i          then 'find'
+              when /^\s*(update|insert)/i then 'save'
+              when /^\s*delete/i          then 'destroy'
+              else nil
+            end
+
+            # FYI: self.to_s will yield connection URI string.
+            duration = msg.duration / 1000000.0
+
+            # Attach SQL to current segment/scope.
+            NewRelic::Agent.instance.transaction_sampler.notice_sql(msg.query, nil, duration)
+
+            # Record query duration associated with each of the desired metrics.
+            metrics = [ "ActiveRecord/#{operation}", 'ActiveRecord/all' ]
+            metrics.each do |metric|
+              NewRelic::Agent.instance.stats_engine.get_stats_no_scope(metric).trace_call(duration)
+            end
+          ensure
+            log_without_newrelic_instrumentation(msg)
+          end
+
+        end # DataMapperInstrumentation
+      end # Instrumentation
+    end # Agent
+  end # NewRelic
+
+  ::DataObjects::Connection.class_eval do
+    include ::NewRelic::Agent::Instrumentation::DataMapperInstrumentation
+  end if defined? ::DataObjects::Connection
+
+end # if defined? DataMapper

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

@@ -3,6 +3,7 @@
 # See:
 #     http://www.deveiate.org/code/Ruby-MemCache/ (Gem: Ruby-MemCache)
 #     http://seattlerb.rubyforge.org/memcache-client/ (Gem: memcache-client)
+#     http://github.com/mperham/dalli (Gem: dalli)
 unless NewRelic::Control.instance['disable_memcache_instrumentation']
 
   def self.instrument_method(the_class, method_name)
@@ -32,9 +33,10 @@ unless NewRelic::Control.instance['disable_memcache_instrumentation']
 
 
 
-  %w[get get_multi set add incr decr delete replace append prepand cas].each do | method_name |
+  %w[get get_multi set add incr decr delete replace append prepend cas].each do | method_name |
     instrument_method(::MemCache, method_name) if defined? ::MemCache
     instrument_method(::Memcached, method_name) if defined? ::Memcached
+    instrument_method(::Dalli::Client, method_name) if defined? ::Dalli::Client
   end
 
 end

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

@@ -75,7 +75,7 @@ module NewRelic
         # Make sure you unwind every push with a pop call.
         def push(m)
           NewRelic::Agent.instance.transaction_sampler.notice_first_scope_push(start)
-          @path_stack.push NewRelic::MetricParser.for_metric_named(m)
+          @path_stack.push NewRelic::MetricParser::MetricParser.for_metric_named(m)
         end
 
         # Indicate that you don't want to keep the currently saved transaction

data/lib/new_relic/agent/instrumentation/rails3/action_controller.rb

@@ -23,6 +23,12 @@ module NewRelic
           end
 
           def process_action(*args)
+            # skip instrumentation if we are in an ignored action
+            if _is_filtered?('do_not_trace')
+              NewRelic::Agent.disable_all_tracing do
+                return super
+              end
+            end
 
             perform_action_with_newrelic_trace(:category => :controller, :name => self.action_name, :params => request.filtered_parameters, :class_name => self.class.name)  do
               super

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

@@ -25,10 +25,11 @@ if defined?(Sinatra::Base)
                 end
               end
             end
-            # strip of leading ^ and / chars and trailing $ and /
-            name.gsub!(%r{^[/^]*(.*?)[/\$]*$}, '\1')
+            # strip off leading ^ and / chars and trailing $ and /
+            name.gsub!(%r{^[/^]*(.*?)[/\$\?]*$}, '\1')
             name = 'root' if name.empty?
-            perform_action_with_newrelic_trace(:category => :sinatra, :name => name) do
+            name = @request.request_method + ' ' + name if @request && @request.respond_to?(:request_method)
+            perform_action_with_newrelic_trace(:category => :sinatra, :name => name, :params => @request.params) do
               route_eval_without_newrelic(&block_arg)
             end
           end

data/lib/new_relic/agent/stats_engine/metric_stats.rb

@@ -1,118 +1,154 @@
 module NewRelic
-module Agent
-  class StatsEngine
-    module MetricStats
-      # The stats hash hashes either a metric name for an unscoped metric,
-      # or a metric_spec for a scoped metric value.
-      def lookup_stat(metric_name)
-        stats_hash[metric_name]
-      end
-
-      def metrics
-        stats_hash.keys.map(&:to_s)
-      end
-
-      def get_stats_no_scope(metric_name)
-        stats_hash[metric_name] ||= NewRelic::MethodTraceStats.new
-      end
-
-      # This version allows a caller to pass a stat class to use
-      #
-      def get_custom_stats(metric_name, stat_class)
-        stats_hash[metric_name] ||= stat_class.new
-      end
-
-      # If use_scope is true, two chained metrics are created, one with scope and one without
-      # If scoped_metric_only is true, only a scoped metric is created (used by rendering metrics which by definition are per controller only)
-      def get_stats(metric_name, use_scope = true, scoped_metric_only = false, scope = nil)
-        scope ||= scope_name if use_scope
-        if scoped_metric_only
-          spec = NewRelic::MetricSpec.new metric_name, scope
-          stats = stats_hash[spec] ||= NewRelic::MethodTraceStats.new
-        else
-          stats = stats_hash[metric_name] ||= NewRelic::MethodTraceStats.new
-          if scope && scope != metric_name
-            spec = NewRelic::MetricSpec.new metric_name, scope
-            scoped_stats = stats_hash[spec] ||= NewRelic::ScopedMethodTraceStats.new(stats)
-            stats = scoped_stats
+  module Agent
+    class StatsEngine
+      module MetricStats
+        class SynchronizedHash < Hash
+          def initialize(*args)
+            @mutex = Mutex.new
+            super
           end
-        end
-        stats
-      end
-
-      def lookup_stats(metric_name, scope_name = nil)
-        stats_hash[NewRelic::MetricSpec.new(metric_name, scope_name)] ||
-        stats_hash[metric_name]
-      end
-      # Harvest the timeslice data.  First recombine current statss
-      # with any previously
-      # unsent metrics, clear out stats cache, and return the current
-      # stats.
-      # ---
-      # Note: this is not synchronized.  There is still some risk in this and
-      # we will revisit later to see if we can make this more robust without
-      # sacrificing efficiency.
-      # +++
-      def harvest_timeslice_data(previous_timeslice_data, metric_ids)
-        timeslice_data = {}
-        poll harvest_samplers
-        stats_hash.keys.each do | metric_spec |
-
-
-          # get a copy of the stats collected since the last harvest, and clear
-          # the stats inside our hash table for the next time slice.
-          stats = stats_hash[metric_spec]
-
-          # we have an optimization for unscoped metrics
-          if !(metric_spec.is_a? NewRelic::MetricSpec)
-            metric_spec = NewRelic::MetricSpec.new metric_spec
+          
+          def []=(*args)
+            @mutex.synchronize {
+              super
+            }
           end
 
-          if stats.nil?
-            raise "Nil stats for #{metric_spec.name} (#{metric_spec.scope})"
+          def [](*args)
+            @mutex.synchronize {
+              super
+            }
           end
 
-          stats_copy = stats.clone
-          stats.reset
+          def clear(*args)
+            @mutex.synchronize {
+              super
+            }
+          end
 
-          # if the previous timeslice data has not been reported (due to an error of some sort)
-          # then we need to merge this timeslice with the previously accumulated - but not sent
-          # data
-          previous_metric_data = previous_timeslice_data[metric_spec]
-          stats_copy.merge! previous_metric_data.stats unless previous_metric_data.nil?
-          stats_copy.round!
+          def delete(*args)
+            @mutex.synchronize {
+              super
+            }
+          end
+          
+          def delete_if(*args)
+            @mutex.synchronize {
+              super
+            }
+          end
+        end
+        
+        # The stats hash hashes either a metric name for an unscoped metric,
+        # or a metric_spec for a scoped metric value.
+        def lookup_stat(metric_name)
+          stats_hash[metric_name]
+        end
 
-          # don't bother collecting and reporting stats that have zero-values for this timeslice.
-          # significant performance boost and storage savings.
-          unless stats_copy.is_reset?
+        def metrics
+          stats_hash.keys.map(&:to_s)
+        end
 
-            id = metric_ids[metric_spec]
-            metric_spec_for_transport = id ? nil : metric_spec
+        def get_stats_no_scope(metric_name)
+          stats_hash[metric_name] ||= NewRelic::MethodTraceStats.new
+        end
 
-            metric_data = NewRelic::MetricData.new(metric_spec_for_transport, stats_copy, id)
+        # This version allows a caller to pass a stat class to use
+        #
+        def get_custom_stats(metric_name, stat_class)
+          stats_hash[metric_name] ||= stat_class.new
+        end
 
-            timeslice_data[metric_spec] = metric_data
-          end
+        # If use_scope is true, two chained metrics are created, one with scope and one without
+        # If scoped_metric_only is true, only a scoped metric is created (used by rendering metrics which by definition are per controller only)
+        def get_stats(metric_name, use_scope = true, scoped_metric_only = false, scope = nil)
+            scope ||= scope_name if use_scope
+            if scoped_metric_only
+              spec = NewRelic::MetricSpec.new metric_name, scope
+              stats = stats_hash[spec] ||= NewRelic::MethodTraceStats.new
+            else
+              stats = stats_hash[metric_name] ||= NewRelic::MethodTraceStats.new
+              if scope && scope != metric_name
+                spec = NewRelic::MetricSpec.new metric_name, scope
+                stats = stats_hash[spec] ||= NewRelic::ScopedMethodTraceStats.new(stats)
+              end
+            end
+            stats
         end
 
-        timeslice_data
-      end
+        def lookup_stats(metric_name, scope_name = nil)
+            stats_hash[NewRelic::MetricSpec.new(metric_name, scope_name)] ||
+            stats_hash[metric_name]
+        end
+        # Harvest the timeslice data.  First recombine current statss
+        # with any previously
+        # unsent metrics, clear out stats cache, and return the current
+        # stats.
+        # ---
+        # Note: this is not synchronized.  There is still some risk in this and
+        # we will revisit later to see if we can make this more robust without
+        # sacrificing efficiency.
+        # +++
+        def harvest_timeslice_data(previous_timeslice_data, metric_ids)
+            timeslice_data = {}
+            poll harvest_samplers
+            stats_hash.keys.each do | metric_spec |
+
+
+              # get a copy of the stats collected since the last harvest, and clear
+              # the stats inside our hash table for the next time slice.
+              stats = stats_hash[metric_spec]
+
+              # we have an optimization for unscoped metrics
+              if !(metric_spec.is_a? NewRelic::MetricSpec)
+                metric_spec = NewRelic::MetricSpec.new metric_spec
+              end
+
+              if stats.nil?
+                raise "Nil stats for #{metric_spec.name} (#{metric_spec.scope})"
+              end
+
+              stats_copy = stats.clone
+              stats.reset
+
+              # if the previous timeslice data has not been reported (due to an error of some sort)
+              # then we need to merge this timeslice with the previously accumulated - but not sent
+              # data
+              previous_metric_data = previous_timeslice_data[metric_spec]
+              stats_copy.merge! previous_metric_data.stats unless previous_metric_data.nil?
+              stats_copy.round!
+
+              # don't bother collecting and reporting stats that have zero-values for this timeslice.
+              # significant performance boost and storage savings.
+              unless stats_copy.is_reset?
+
+                id = metric_ids[metric_spec]
+                metric_spec_for_transport = id ? nil : metric_spec
+
+                metric_data = NewRelic::MetricData.new(metric_spec_for_transport, stats_copy, id)
+
+                timeslice_data[metric_spec] = metric_data
+              end
+            end
+
+            timeslice_data
+        end
 
-      # Remove all stats.  For test code only.
-      def clear_stats
-        stats_hash.clear
-        NewRelic::Agent::BusyCalculator.reset
-      end
+        # Remove all stats.  For test code only.
+        def clear_stats
+          stats_hash.clear
+          NewRelic::Agent::BusyCalculator.reset
+        end
 
-      # Reset each of the stats, such as when a new passenger instance starts up.
-      def reset_stats
-        stats_hash.values.each { |s| s.reset }
-      end
+        # Reset each of the stats, such as when a new passenger instance starts up.
+        def reset_stats
+          stats_hash.values.each { |s| s.reset }
+        end
 
-      def stats_hash
-        @stats_hash ||= {}
+        def stats_hash
+          @stats_hash ||= SynchronizedHash.new
+        end
       end
     end
   end
 end
-end