newrelic_rpm 3.5.2.17 → 3.5.3.24

data/lib/new_relic/agent/worker_loop.rb

@@ -6,23 +6,28 @@ module NewRelic
     # A task is a proc or block with a specified call period in seconds.
     class WorkerLoop
 
-      def initialize
+      # Optional argument :duration (in seconds) for how long the worker loop runs
+      # or :limit (integer) for max number of iterations
+      def initialize(opts={})
         @log = log
         @should_run = true
         @next_invocation_time = Time.now
         @period = 60.0
+        @deadline = Time.now + opts[:duration] if opts[:duration]
+        @limit = opts[:limit] if opts[:limit]
+        @iterations = 0
       end
-      
+
       # returns a class-level memoized mutex to make sure we don't run overlapping
       def lock
         @@lock ||= Mutex.new
       end
-      
+
       # a helper to access the NewRelic::Control.instance.log
       def log
         NewRelic::Control.instance.log
       end
-      
+
       # Run infinitely, calling the registered tasks at their specified
       # call periods.  The caller is responsible for creating the thread
       # that runs this worker loop.  This will run the task immediately.
@@ -30,28 +35,37 @@ module NewRelic
         @period = period if period
         @next_invocation_time = (Time.now + @period)
         @task = block
-        while keep_running do
-          now = Time.now
-          while now < @next_invocation_time
+        while keep_running? do
+          while @now < @next_invocation_time
             # sleep until this next task's scheduled invocation time
-            sleep_time = @next_invocation_time - now
+            sleep_time = @next_invocation_time - @now
             sleep sleep_time if sleep_time > 0
-            now = Time.now
+            @now = Time.now
           end
-          run_task if keep_running
+          run_task if keep_running?
+          @iterations += 1 if !@limit.nil?
         end
       end
-      
+
       # a simple accessor for @should_run
-      def keep_running
-        @should_run
+      def keep_running?
+        @now = Time.now
+        @should_run && under_duration? && under_limit?
+      end
+
+      def under_duration?
+        !@deadline || @now < @deadline
+      end
+
+      def under_limit?
+        !@limit || @iterations < @limit
       end
-      
+
       # Sets @should_run to false. Returns false
       def stop
         @should_run = false
       end
-      
+
       # Executes the block given to the worker loop, and handles many
       # possible errors. Also updates the execution time so that the
       # next run occurs on schedule, even if we execute at some odd time

data/lib/new_relic/control/frameworks/rails.rb

@@ -158,10 +158,10 @@ module NewRelic
         def install_shim
           super
           require 'new_relic/agent/instrumentation/controller_instrumentation'
-          if !ActiveSupport.respond_to?(:on_load) # rails 3+
-            ActionController::Base.class_eval do
-              include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim
-            end
+          if ActiveSupport.respond_to?(:on_load) # rails 3+
+            ActiveSupport.on_load(:action_controller) { include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim }
+          else
+            ActionController::Base.class_eval { include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim }
           end
         end
       end

data/lib/new_relic/control/frameworks/rails3.rb

@@ -69,7 +69,7 @@ module NewRelic
 
         # Collect the Rails::Info into an associative array as well as the list of plugins
         def append_environment_info
-          local_env.append_environment_value('Rails version'){ version }
+          local_env.append_environment_value('Rails version'){ ::Rails::VERSION::STRING }
           local_env.append_environment_value('Rails threadsafe') do
             true == ::Rails.configuration.action_controller.allow_concurrency
           end

data/lib/new_relic/helper.rb

@@ -27,5 +27,8 @@ module NewRelic
       end
     end
 
+    def time_to_millis(time)
+      (time.to_f * 1000).round
+    end
   end
 end

data/lib/new_relic/metric_data.rb

@@ -20,7 +20,7 @@ module NewRelic
     def original_spec
       @original_spec || @metric_spec
     end
-    
+
     # assigns a new metric spec, and retains the old metric spec as
     # @original_spec if it exists currently
     def metric_spec= new_spec
@@ -36,7 +36,7 @@ module NewRelic
     def to_json(*a)
        %Q[{"metric_spec":#{metric_id ? 'null' : metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}},"metric_id":#{metric_id ? metric_id : 'null'}}]
     end
-    
+
     def to_s
       if metric_spec
         "#{metric_spec.name}(#{metric_spec.scope}): #{stats}"
@@ -44,8 +44,16 @@ module NewRelic
         "#{metric_id}: #{stats}"
       end
     end
+
     def inspect
       "#<MetricData metric_spec:#{metric_spec.inspect}, stats:#{stats.inspect}, metric_id:#{metric_id.inspect}>"
     end
+
+    def to_collector_array(marshaller=nil)
+      stat_key = metric_id || { 'name' => metric_spec.name, 'scope' => metric_spec.scope }
+      [ stat_key,
+        [ stats.call_count, stats.total_call_time, stats.total_exclusive_time,
+          stats.min_call_time, stats.max_call_time, stats.sum_of_squares ] ]
+    end
   end
 end

data/lib/new_relic/noticed_error.rb

@@ -36,4 +36,9 @@ class NewRelic::NoticedError
       false
     end
   end
+
+  def to_collector_array(marshaller=nil)
+    [ (@timestamp.to_f * 1000).round, @path, @message, @exception_class,
+      @params ]
+  end
 end

data/lib/new_relic/transaction_sample.rb

@@ -1,3 +1,5 @@
+require 'base64'
+
 require 'new_relic/transaction_sample/segment'
 require 'new_relic/transaction_sample/summary_segment'
 require 'new_relic/transaction_sample/fake_segment'
@@ -51,15 +53,25 @@ module NewRelic
       @start_time - @@start_time.to_f
     end
 
-    # Used in the server only
-    def to_json(options = {}) #:nodoc:
-      map = {:sample_id => @sample_id,
-        :start_time => @start_time,
-        :root_segment => @root_segment}
-      if @params && !@params.empty?
-        map[:params] = @params
+    def to_json
+      JSON.dump(self.to_array)
+    end
+
+    def to_array
+      [ @start_time.to_f, @params[:request_params], @params[:custom_params],
+        @root_segment.to_array ]
+    end
+
+    def to_collector_array(marshaller)
+      trace_tree = if marshaller.respond_to?(:encode_compress)
+        marshaller.encode_compress(self.to_array)
+      else
+        self.to_array
       end
-      map.to_json
+
+      [ Helper.time_to_millis(@start_time), Helper.time_to_millis(duration),
+        @params[:path], @params[:uri], trace_tree, @guid, nil,
+        !!@force_persist ]
     end
 
     def start_time
@@ -134,10 +146,10 @@ module NewRelic
       regex = Regexp.new(regex)
 
       sample = TransactionSample.new(@start_time, sample_id)
-      
+
       sample.params = params.dup
       sample.params[:segment_count] = 0
-      
+
       delta = build_segment_with_omissions(sample, 0.0, @root_segment, sample.root_segment, regex)
       sample.root_segment.end_trace(@root_segment.exit_timestamp - delta)
       sample.profile = self.profile
@@ -160,7 +172,7 @@ module NewRelic
       sample.force_persist = self.force_persist if self.force_persist
 
       build_segment_for_transfer(sample, @root_segment, sample.root_segment, options)
-      
+
       sample.root_segment.end_trace(@root_segment.exit_timestamp)
       sample
     end
@@ -171,8 +183,6 @@ module NewRelic
 
   private
 
-
-
     HEX_DIGITS = (0..15).map{|i| i.to_s(16)}
     # generate a random 64 bit uuid
     def generate_guid

data/lib/new_relic/transaction_sample/segment.rb

@@ -1,4 +1,5 @@
 require 'new_relic/transaction_sample'
+
 module NewRelic
   class TransactionSample
     class Segment
@@ -15,13 +16,13 @@ module NewRelic
         @metric_name = metric_name || '<unknown>'
         @segment_id = segment_id || object_id
       end
-      
+
       # sets the final timestamp on a segment to indicate the exit
       # point of the segment
       def end_trace(timestamp)
         @exit_timestamp = timestamp
       end
-      
+
       def add_called_segment(s)
         @called_segments ||= []
         @called_segments << s
@@ -32,18 +33,15 @@ module NewRelic
         to_debug_str(0)
       end
 
-      def to_json(options={})
-        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?
+      def to_array
+        [ (@entry_timestamp.to_f * 1000).round,
+          (@exit_timestamp.to_f * 1000).round,
+          @metric_name, (@params || {}) ] +
+          [ (@called_segments ? @called_segments.map{|s| s.to_array} : []) ]
+      end
 
-        hash.to_json
+      def to_json
+        JSON.dump(self.to_array)
       end
 
       def path_string
@@ -97,13 +95,13 @@ module NewRelic
         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 in a
       # depth-first manner
       def truncate(max)

data/lib/new_relic/version.rb

@@ -3,7 +3,7 @@ module NewRelic
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 5
-    TINY  = 2
+    TINY  = 3
     BUILD = nil
     STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end

data/lib/tasks/tests.rake

@@ -7,18 +7,12 @@ if defined? Rake::TestTask
   task :test => 'test:newrelic'
   task :default => :test
   namespace :test do
-    AGENT_HOME = File.expand_path(File.join(File.dirname(__FILE__),'..','..'))
-    Rake::TestTask.new(:newrelic) do |t|
-      t.libs << "#{AGENT_HOME}/test"
-      t.libs << "#{AGENT_HOME}/lib"
-      t.pattern = "#{AGENT_HOME}/test/**/*_test.rb"
-      t.verbose = true
-    end
+    agent_home = File.expand_path(File.join(File.dirname(__FILE__),'..','..'))
 
-    Rake::TestTask.new(:intentional_fail) do |t|
-      t.libs << "#{AGENT_HOME}/test"
-      t.libs << "#{AGENT_HOME}/lib"
-      t.pattern = "#{AGENT_HOME}/test/intentional_fail.rb"
+    Rake::TestTask.new(:newrelic) do |t|
+      t.libs << "#{agent_home}/test"
+      t.libs << "#{agent_home}/lib"
+      t.pattern = "#{agent_home}/test/new_relic/**/*_test.rb"
       t.verbose = true
     end
   end

data/test/multiverse/.gitignore

@@ -0,0 +1,10 @@
+tmp
+*.swp
+.bundler_work_area
+Gemfile
+Gemfile.lock
+*.log
+*.db
+.idea
+tags
+*.sqlite3

data/test/multiverse/README.md

@@ -0,0 +1,90 @@
+# Multiverse
+
+## Testing in a multitude of environments
+
+Multiverse was created to solve a specific problem experienced by the Agent
+team.  Not only does the New Relic Agent run in a wide variety of environments,
+but its expected behavior *changes* based on the environment.  Instrumenation is
+toggled on and off based on the presence of certain libraries, and some of these
+libraries are incompatible with each other.  Effective testing requires us to
+specify different environments for different tests; Multiverse aims to make this
+painless.
+
+
+## Getting started
+
+To run tests against the agent invoke the runner script.
+
+    script/runner
+
+
+You can invoke this via rake
+
+    rake test
+
+If you only want to run some test suites you can filter by their names
+
+    script/runner sinatra
+
+You can run tests of multiverse itself with
+
+    rake test:self
+
+### Adding a test suite
+
+To add tests add a directory to the `suites` directory.  This directory should
+contain at least two files.
+
+#### Envfile
+
+The Envfile is a meta gem file.  It allows you to specify one or more gemset
+that the tests in this directory should be run against.  For example:
+
+    gemfile <<-GEMFILE
+      gem "rails", "~>3.2.0"
+    GEMFILE
+
+    gemfile <<-GEMFILE
+      gem "rails", "~>3.1.0"
+    GEMFILE
+
+This will run these tests against 2 environments, one running rails 3.1, the
+other running rails 3.2.
+
+New Relic is automatically included in the environment.  Specifying it in the
+Envfile will trigger and error.  You can override where newrelic is loaded from
+using two environment variables.
+
+The default gemfile line is
+
+    gem 'newrelic_rpm', :path => '../../../ruby_agent'
+
+`ENV['NEWRELIC_GEMFILE_LINE']` will specify the full line for the gemfile
+
+`ENV['NEWRELIC_GEM_PATH']` will override the `:path` option in the default line.
+
+
+#### Test files
+
+All files in a test suite directory that end with .rb will be executed as test
+files.  These should use test unit.
+
+For example:
+
+    require 'test/unit'
+    class ATest < Test::Unit::TestCase
+      def test_json_is_loaded
+        assert JSON
+      end
+
+      def test_haml_is_not_loaded
+        assert !defined?(Haml)
+      end
+    end
+
+
+## Testing Multiverse
+
+Multiverse has a suite of tests in the `test` directory for testing the
+framework itself (sooo meta).  These help confirm that the system is working as
+expected.

data/test/multiverse/Rakefile

@@ -0,0 +1,17 @@
+require 'rake/testtask.rb'
+require File.join(File.dirname(__FILE__),'lib','multiverse','color')
+
+desc "Test the testing framework by executing tests in /test. Get meta with it."
+task "test:self" do
+  extend Multiverse::Color
+  puts yellow("Testing the multiverse testing framework...")
+  test_files = FileList['test/*_test.rb']
+  ruby test_files.join(" ")
+end
+
+desc "Test the agent. Run all suites in /suites to test."
+task "test" do
+  ruby 'script/runner'
+end
+
+task 'default' => ['test:self', 'test']