newrelic_rpm 3.0.1 → 3.1.0.beta1

data/lib/new_relic/transaction_sample/fake_segment.rb

@@ -0,0 +1,9 @@
+require 'new_relic/transaction_sample'
+require 'new_relic/transaction_sample/segment'
+module NewRelic
+  class TransactionSample
+    class FakeSegment < Segment
+      public :parent_segment=
+    end
+  end
+end

data/lib/new_relic/transaction_sample/segment.rb

@@ -0,0 +1,250 @@
+require 'new_relic/transaction_sample'
+module NewRelic
+  class TransactionSample
+    class Segment
+      attr_reader :entry_timestamp
+      # The exit timestamp will be relative except for the outermost sample which will
+      # have a timestamp.
+      attr_reader :exit_timestamp
+      attr_reader :parent_segment
+      attr_reader :metric_name
+      attr_reader :segment_id
+
+      def initialize(timestamp, metric_name, segment_id)
+        @entry_timestamp = timestamp
+        @metric_name = metric_name || '<unknown>'
+        @segment_id = segment_id || object_id
+      end
+
+      def end_trace(timestamp)
+        @exit_timestamp = timestamp
+      end
+
+      def add_called_segment(s)
+        @called_segments ||= []
+        @called_segments << s
+        s.parent_segment = self
+      end
+
+      def to_s
+        to_debug_str(0)
+      end
+
+      def to_json
+        hash = {
+          :entry_timestamp => @entry_timestamp,
+          :exit_timestamp => @exit_timestamp,
+          :metric_name => @metric_name,
+          :segment_id => @segment_id,
+        }
+
+        hash[:called_segments] = called_segments if !called_segments.empty?
+        hash[:params] = @params if @params && !@params.empty?
+
+        hash.to_json
+      end
+
+      def path_string
+        "#{metric_name}[#{called_segments.collect {|segment| segment.path_string }.join('')}]"
+      end
+      def to_s_compact
+        str = ""
+        str << metric_name
+        if called_segments.any?
+          str << "{#{called_segments.map { | cs | cs.to_s_compact }.join(",")}}"
+        end
+        str
+      end
+      def to_debug_str(depth)
+        tab = "  " * depth
+        s = tab.clone
+        s << ">> #{'%3i ms' % (@entry_timestamp*1000)} [#{self.class.name.split("::").last}] #{metric_name} \n"
+        unless params.empty?
+          params.each do |k,v|
+            s << "#{tab}    -#{'%-16s' % k}: #{v.to_s[0..80]}\n"
+          end
+        end
+        called_segments.each do |cs|
+          s << cs.to_debug_str(depth + 1)
+        end
+        s << tab + "<< "
+        s << case @exit_timestamp
+             when nil then ' n/a'
+             when Numeric then '%3i ms' % (@exit_timestamp*1000)
+             else @exit_timestamp.to_s
+             end
+        s << " #{metric_name}\n"
+      end
+
+      def called_segments
+        @called_segments || []
+      end
+
+      # return the total duration of this segment
+      def duration
+        (@exit_timestamp - @entry_timestamp).to_f
+      end
+
+      # return the duration of this segment without
+      # including the time in the called segments
+      def exclusive_duration
+        d = duration
+
+        called_segments.each do |segment|
+          d -= segment.duration
+        end
+        d
+      end
+      def count_segments
+        count = 1
+        called_segments.each { | seg | count  += seg.count_segments }
+        count
+      end
+      # Walk through the tree and truncate the segments
+      def truncate(max)
+        return 1 unless @called_segments
+        total, self.called_segments = truncate_each_child(max - 1)
+        total+1
+      end
+
+      def truncate_each_child(max)
+        total = 0
+        accumulator = []
+        called_segments.each { | s |
+          if total == max
+            true
+          else
+            total += s.truncate(max - total)
+            accumulator << s
+          end
+        }
+        total
+        [total, accumulator]
+      end
+
+      def []=(key, value)
+        # only create a parameters field if a parameter is set; this will save
+        # bandwidth etc as most segments have no parameters
+        params[key] = value
+      end
+
+      def [](key)
+        params[key]
+      end
+
+      def params
+        @params ||= {}
+      end
+
+      # call the provided block for this segment and each
+      # of the called segments
+      def each_segment(&block)
+        block.call self
+
+        if @called_segments
+          @called_segments.each do |segment|
+            segment.each_segment(&block)
+          end
+        end
+      end
+
+      def find_segment(id)
+        return self if @segment_id == id
+        called_segments.each do |segment|
+          found = segment.find_segment(id)
+          return found if found
+        end
+        nil
+      end
+
+      # perform this in the runtime environment of a managed
+      # application, to explain the sql statement(s) executed within a
+      # segment of a transaction sample.  returns an array of
+      # explanations (which is an array rows consisting of an array of
+      # strings for each column returned by the the explain query)
+      # Note this happens only for statements whose execution time
+      # exceeds a threshold (e.g. 500ms) and only within the slowest
+      # transaction in a report period, selected for shipment to RPM
+      def explain_sql
+        sql = params[:sql]
+        return nil unless sql && params[:connection_config]
+        statements = sql.split(";\n")
+        statements.map! do |statement|
+          # a small sleep to make sure we yield back to the parent
+          # thread regularly, if there are many explains
+          sleep(0.0001)
+          explain_statement(statement, params[:connection_config])
+        end
+        statements.compact!
+        statements
+      end
+
+      def explain_statement(statement, config)
+        if is_select?(statement)
+          handle_exception_in_explain do
+            connection = NewRelic::TransactionSample.get_connection(config)
+            process_resultset(connection.execute("EXPLAIN #{statement}")) if connection
+          end
+        end
+      end
+
+      def is_select?(statement)
+        # split the string into at most two segments on the
+        # system-defined field separator character
+        first_word, rest_of_statement = statement.split($;, 2)
+        (first_word.upcase == 'SELECT')
+      end
+
+      def process_resultset(items)
+        # The resultset type varies for different drivers.  Only thing you can count on is
+        # that it implements each.  Also: can't use select_rows because the native postgres
+        # driver doesn't know that method.
+
+        if items.respond_to?(:each)
+          rows = []
+          items.each do |row|
+            columns = []
+            row.each do |column|
+              columns << column.to_s
+            end
+            rows << columns
+          end
+          rows
+        else
+          [items]
+        end
+      end
+
+
+      def handle_exception_in_explain
+        yield
+      rescue Exception => e
+        begin
+          # guarantees no throw from explain_sql
+          NewRelic::Control.instance.log.error("Error getting explain plan: #{e.message}")
+          NewRelic::Control.instance.log.debug(e.backtrace.join("\n"))
+        rescue Exception
+          # double exception. throw up your hands
+        end
+      end
+
+
+      def params=(p)
+        @params = p
+      end
+
+      def obfuscated_sql
+        TransactionSample.obfuscate_sql(params[:sql])
+      end
+
+      def called_segments=(segments)
+        @called_segments = segments
+      end
+
+      protected
+      def parent_segment=(s)
+        @parent_segment = s
+      end
+    end
+  end
+end

data/lib/new_relic/transaction_sample/summary_segment.rb

@@ -0,0 +1,21 @@
+require 'new_relic/transaction_sample'
+require 'new_relic/transaction_sample/segment'
+module NewRelic
+  class TransactionSample
+    class SummarySegment < Segment
+      def initialize(segment)
+        super segment.entry_timestamp, segment.metric_name, nil
+
+        add_segments segment.called_segments
+
+        end_trace segment.exit_timestamp
+      end
+
+      def add_segments(segments)
+        segments.collect do |segment|
+          SummarySegment.new(segment)
+        end.each {|segment| add_called_segment(segment)}
+      end
+    end
+  end
+end

data/lib/new_relic/version.rb

@@ -2,9 +2,9 @@
 module NewRelic
   module VERSION #:nodoc:
     MAJOR = 3
-    MINOR = 0
-    TINY  = 1
-    BUILD = nil #'0' # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
+    MINOR = 1
+    TINY  = 0
+    BUILD = 'beta1' #'0' # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
     STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end
 

data/newrelic.yml

@@ -138,8 +138,8 @@ common: &default_settings
   transaction_tracer:
   
     # Transaction tracer is enabled by default. Set this to false to
-    # turn it off. This feature is only available at the Professional
-    # and above product levels.
+    # turn it off. This feature is only available at the Silver and
+    # above product levels.
     enabled: true
     
     # Threshold in seconds for when to collect a transaction
@@ -176,7 +176,7 @@ common: &default_settings
   error_collector:
     
     # Error collector is enabled by default. Set this to false to turn
-    # it off. This feature is only available at the Professional and above
+    # it off. This feature is only available at the Silver and above
     # product levels
     enabled: true
     

data/newrelic_rpm.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{newrelic_rpm}
-  s.version = "3.0.1"
+  s.version = "3.1.0.beta1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Bill Kayser", "Justin George"]
-  s.date = %q{2011-05-20}
+  s.date = %q{2011-05-11}
   s.description = %q{New Relic RPM is a Ruby performance management system, developed by
 New Relic, Inc (http://www.newrelic.com).  RPM provides you with deep
 information about the performance of your Ruby on Rails or Merb
@@ -45,6 +45,7 @@ http://github.com/newrelic/rpm/tree/master.
     "lib/new_relic/agent/busy_calculator.rb",
     "lib/new_relic/agent/chained_call.rb",
     "lib/new_relic/agent/error_collector.rb",
+    "lib/new_relic/agent/instrumentation.rb",
     "lib/new_relic/agent/instrumentation/active_merchant.rb",
     "lib/new_relic/agent/instrumentation/acts_as_solr.rb",
     "lib/new_relic/agent/instrumentation/authlogic.rb",
@@ -55,6 +56,7 @@ http://github.com/newrelic/rpm/tree/master.
     "lib/new_relic/agent/instrumentation/merb/controller.rb",
     "lib/new_relic/agent/instrumentation/merb/errors.rb",
     "lib/new_relic/agent/instrumentation/metric_frame.rb",
+    "lib/new_relic/agent/instrumentation/metric_frame/pop.rb",
     "lib/new_relic/agent/instrumentation/net.rb",
     "lib/new_relic/agent/instrumentation/passenger_instrumentation.rb",
     "lib/new_relic/agent/instrumentation/queue_time.rb",
@@ -101,6 +103,7 @@ http://github.com/newrelic/rpm/tree/master.
     "lib/new_relic/control/logging_methods.rb",
     "lib/new_relic/control/profiling.rb",
     "lib/new_relic/control/server_methods.rb",
+    "lib/new_relic/data_serialization.rb",
     "lib/new_relic/delayed_job_injection.rb",
     "lib/new_relic/histogram.rb",
     "lib/new_relic/local_environment.rb",
@@ -119,7 +122,12 @@ http://github.com/newrelic/rpm/tree/master.
     "lib/new_relic/stats.rb",
     "lib/new_relic/timer_lib.rb",
     "lib/new_relic/transaction_analysis.rb",
+    "lib/new_relic/transaction_analysis/segment_summary.rb",
     "lib/new_relic/transaction_sample.rb",
+    "lib/new_relic/transaction_sample/composite_segment.rb",
+    "lib/new_relic/transaction_sample/fake_segment.rb",
+    "lib/new_relic/transaction_sample/segment.rb",
+    "lib/new_relic/transaction_sample/summary_segment.rb",
     "lib/new_relic/url_rule.rb",
     "lib/new_relic/version.rb",
     "lib/newrelic_rpm.rb",
@@ -147,9 +155,11 @@ http://github.com/newrelic/rpm/tree/master.
     "test/new_relic/agent/instrumentation/active_record_instrumentation_test.rb",
     "test/new_relic/agent/instrumentation/controller_instrumentation_test.rb",
     "test/new_relic/agent/instrumentation/instrumentation_test.rb",
+    "test/new_relic/agent/instrumentation/metric_frame/pop_test.rb",
     "test/new_relic/agent/instrumentation/metric_frame_test.rb",
     "test/new_relic/agent/instrumentation/net_instrumentation_test.rb",
     "test/new_relic/agent/instrumentation/queue_time_test.rb",
+    "test/new_relic/agent/instrumentation/rack_test.rb",
     "test/new_relic/agent/instrumentation/task_instrumentation_test.rb",
     "test/new_relic/agent/memcache_instrumentation_test.rb",
     "test/new_relic/agent/method_tracer/class_methods/add_method_tracer_test.rb",
@@ -157,19 +167,32 @@ http://github.com/newrelic/rpm/tree/master.
     "test/new_relic/agent/method_tracer_test.rb",
     "test/new_relic/agent/mock_scope_listener.rb",
     "test/new_relic/agent/rpm_agent_test.rb",
+    "test/new_relic/agent/sampler_test.rb",
+    "test/new_relic/agent/shim_agent_test.rb",
+    "test/new_relic/agent/stats_engine/metric_stats/harvest_test.rb",
     "test/new_relic/agent/stats_engine/metric_stats_test.rb",
     "test/new_relic/agent/stats_engine/samplers_test.rb",
-    "test/new_relic/agent/stats_engine/stats_engine_test.rb",
+    "test/new_relic/agent/stats_engine_test.rb",
     "test/new_relic/agent/transaction_sample_builder_test.rb",
     "test/new_relic/agent/transaction_sampler_test.rb",
     "test/new_relic/agent/worker_loop_test.rb",
     "test/new_relic/collection_helper_test.rb",
     "test/new_relic/command/deployments_test.rb",
+    "test/new_relic/control/class_methods_test.rb",
+    "test/new_relic/control/logging_methods_test.rb",
     "test/new_relic/control_test.rb",
+    "test/new_relic/data_serialization_test.rb",
     "test/new_relic/local_environment_test.rb",
+    "test/new_relic/metric_data_test.rb",
     "test/new_relic/metric_spec_test.rb",
     "test/new_relic/rack/episodes_test.rb",
     "test/new_relic/stats_test.rb",
+    "test/new_relic/transaction_analysis/segment_summary_test.rb",
+    "test/new_relic/transaction_analysis_test.rb",
+    "test/new_relic/transaction_sample/composite_segment_test.rb",
+    "test/new_relic/transaction_sample/fake_segment_test.rb",
+    "test/new_relic/transaction_sample/segment_test.rb",
+    "test/new_relic/transaction_sample/summary_segment_test.rb",
     "test/new_relic/transaction_sample_subtest_test.rb",
     "test/new_relic/transaction_sample_test.rb",
     "test/new_relic/version_number_test.rb",
@@ -275,7 +298,7 @@ Refer to the README.md file for more information.
 
 Please see http://support.newrelic.com/faqs/docs/ruby-agent-release-notes
 for a complete description of the features and enhancements available
-in version 3.0 of the Ruby Agent.
+in version 3.1 of the Ruby Agent.
 
 For details on this specific release, refer to the CHANGELOG file.
 

data/test/active_record_fixtures.rb

@@ -19,19 +19,29 @@ module ActiveRecordFixtures
     self.table_name = 'newrelic_test_orders'
     has_and_belongs_to_many :shipments, :class_name => 'ActiveRecordFixtures::Shipment'
     def self.setup
-      connection.create_table self.table_name, :force => true do |t|
-        t.column :name, :string
+      unless check_for_table
+        connection.create_table self.table_name, :force => true do |t|
+          t.column :name, :string
+        end
+      else
+        connection.execute("delete from #{self.table_name}")
       end
     end
+
+    def self.check_for_table
+      connection.table_exists?(self.table_name)
+    rescue Exception => e
+      false
+    end
+    
     def self.add_delay
-      # Introduce a 500 ms delay into db operations on Orders
+      # Introduce a 5 ms delay into db operations on Orders
       def connection.log_info *args
-        sleep 0.5
+        sleep 0.005
         super *args
       end
     end
     def self.teardown
-      connection.drop_table table_name
       def connection.log_info *args
         super *args
       end
@@ -42,18 +52,26 @@ module ActiveRecordFixtures
     self.table_name = 'newrelic_test_shipment'
     has_and_belongs_to_many :orders, :class_name => 'ActiveRecordFixtures::Order'
     def self.setup
-      connection.create_table self.table_name, :force => true do |t|
-        # no other columns
-      end
-      connection.create_table 'orders_shipments', :force => true, :id => false do |t|
-        t.column :order_id, :integer
-        t.column :shipment_id, :integer
+      unless check_for_table
+        connection.create_table self.table_name, :force => true do |t|
+          # no other columns
+        end
+        connection.create_table 'orders_shipments', :force => true, :id => false do |t|
+          t.column :order_id, :integer
+          t.column :shipment_id, :integer
+        end
+      else
+        connection.execute("delete from #{self.table_name}")
       end
     end
+    def self.check_for_table
+      connection.table_exists?(self.table_name)
+    rescue Exception => e
+      false
+    end
 
+    
     def self.teardown
-      connection.drop_table 'orders_shipments'
-      connection.drop_table self.table_name
     end
   end
 end