newrelic_rpm 3.0.0.beta1 → 3.0.0.beta2

data/CHANGELOG

@@ -5,6 +5,7 @@ v3.0.0
     setting the path and name of the agent log file
   * Improve reliability of statistics calculations
   * Remove some previously deprecated methods
+  * Remove Sequel instrumentation pending more work
 
 v2.14.1
   * Avoid overriding methods named 'log' when including the MethodTracer module

data/lib/new_relic/agent/agent.rb

@@ -431,9 +431,9 @@ module NewRelic
           def create_and_run_worker_loop
             @worker_loop = WorkerLoop.new
             @worker_loop.run(@report_period) do
-              harvest_and_send_timeslice_data
               harvest_and_send_slowest_sample if @should_send_samples
               harvest_and_send_errors if error_collector.enabled
+              harvest_and_send_timeslice_data
             end
           end
 
@@ -720,6 +720,8 @@ module NewRelic
           NewRelic::Agent::BusyCalculator.harvest_busy
 
           now = Time.now
+          NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Supportability/invoke_remote').record_data_point(0.0)
+          NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Supportability/invoke_remote/metric_data').record_data_point(0.0)
 
           @unsent_timeslice_data ||= {}
           @unsent_timeslice_data = @stats_engine.harvest_timeslice_data(@unsent_timeslice_data, @metric_ids)
@@ -897,6 +899,7 @@ module NewRelic
 
         # send a message via post
         def invoke_remote(method, *args)
+          now = Time.now
           #determines whether to zip the data or send plain
           post_data, encoding = compress_data(args)
 
@@ -910,6 +913,9 @@ module NewRelic
         rescue SystemCallError, SocketError => e
           # These include Errno connection errors
           raise NewRelic::Agent::ServerConnectionException, "Recoverable error connecting to the server: #{e}"
+        ensure
+          NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Supportability/invoke_remote').record_data_point((Time.now - now).to_f)
+          NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Supportability/invoke_remote/' + method.to_s).record_data_point((Time.now - now).to_f)          
         end
 
         def graceful_disconnect

data/lib/new_relic/agent/beacon_configuration.rb

@@ -0,0 +1,54 @@
+module NewRelic
+  module Agent
+    class BeaconConfiguration
+      attr_reader :browser_timing_header
+      attr_reader :application_id
+      attr_reader :browser_monitoring_key
+      attr_reader :beacon
+      attr_reader :rum_enabled
+      attr_reader :license_bytes
+
+      def initialize(connect_data)
+        @browser_monitoring_key = connect_data['browser_key']
+        @application_id = connect_data['application_id']
+        @beacon = connect_data['beacon']
+        @rum_enabled = connect_data['rum.enabled']
+        @rum_enabled = true if @rum_enabled.nil?
+        @browser_timing_header = build_browser_timing_header(connect_data)
+      end
+
+      def license_bytes
+        if @license_bytes.nil?
+          @license_bytes = []
+          NewRelic::Control.instance.license_key.each_byte {|byte| @license_bytes << byte}
+        end
+        @license_bytes
+      end
+
+      def load_file_js(connect_data)
+        return "" unless connect_data.fetch('rum.load_episodes_file', true)
+
+        episodes_url = connect_data.fetch('episodes_url', '')
+        "(function(){var d=document;var e=d.createElement(\"script\");e.type=\"text/javascript\";e.async=true;e.src=\"#{episodes_url}\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})()"
+      end
+
+      def basic_javascript(connect_data)
+        "<script>var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);#{load_file_js(connect_data)}</script>"
+      end
+
+      def build_browser_timing_header(connect_data)
+        return "" if !@rum_enabled
+        return "" if @browser_monitoring_key.nil?
+        
+        value = basic_javascript(connect_data)
+        if value.respond_to?(:html_safe)
+          value.html_safe
+        else
+          value
+        end
+      end
+    end
+  end
+end
+
+

data/lib/new_relic/agent/browser_monitoring.rb

@@ -1,100 +1,72 @@
 require 'base64'
-
+require 'new_relic/agent/beacon_configuration'
 module NewRelic
   module Agent
-    class BeaconConfiguration
-      attr_reader :browser_timing_header
-      attr_reader :application_id
-      attr_reader :browser_monitoring_key
-      attr_reader :beacon
-      attr_reader :rum_enabled
-      attr_reader :license_bytes
-
-      def initialize(connect_data)
-        @browser_monitoring_key = connect_data['browser_key']
-        @application_id = connect_data['application_id']
-        @beacon = connect_data['beacon']
-        @rum_enabled = connect_data['rum.enabled']
-        @rum_enabled = true if @rum_enabled.nil?
-        @browser_timing_header = build_browser_timing_header(connect_data)
-      end
-
-      def license_bytes
-        if @license_bytes.nil?
-          @license_bytes = []
-          NewRelic::Control.instance.license_key.each_byte {|byte| @license_bytes << byte}
-        else
-          @license_bytes
-        end
-      end
-
-      def build_browser_timing_header(connect_data)
-        return "" if !@rum_enabled
-        return "" if @browser_monitoring_key.nil?
-
-        episodes_url = connect_data['episodes_url']
-        load_episodes_file = connect_data['rum.load_episodes_file']
-        load_episodes_file = true if load_episodes_file.nil?
-
-        load_js = load_episodes_file ? "(function(){var d=document;var e=d.createElement(\"script\");e.type=\"text/javascript\";e.async=true;e.src=\"#{episodes_url}\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})()" : ""
-
-        value = "<script>var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);#{load_js}</script>"
-        if value.respond_to?(:html_safe)
-          value.html_safe
-        else
-          value
-        end
-      end
-    end
-
     module BrowserMonitoring
 
       def browser_timing_header
         return "" if NewRelic::Agent.instance.beacon_configuration.nil?
-
         return "" if !NewRelic::Agent.is_transaction_traced? || !NewRelic::Agent.is_execution_traced?
-          
+        
         NewRelic::Agent.instance.beacon_configuration.browser_timing_header
       end
-
+      
       def browser_timing_footer
         config = NewRelic::Agent.instance.beacon_configuration
-        return "" if config.nil? || !config.rum_enabled
-       
-        license_key = config.browser_monitoring_key
-        return "" if license_key.nil?
-
+        return "" if config.nil? || !config.rum_enabled || config.browser_monitoring_key.nil?
         return "" if !NewRelic::Agent.is_transaction_traced? || !NewRelic::Agent.is_execution_traced?
+        generate_footer_js
+      end
+
+      private
+
+      def generate_footer_js
+        if browser_monitoring_start_time
+          config = NewRelic::Agent.instance.beacon_configuration
+          application_id = config.application_id
+          beacon = config.beacon
+          license_key = config.browser_monitoring_key          
           
-        application_id = config.application_id
-        beacon = config.beacon
+          footer_js_string(beacon, license_key, application_id)
+        else
+          ''
+        end
+      end
 
-        transaction_name = Thread.current[:newrelic_most_recent_transaction] || "<unknown>"
-        start_time = Thread.current[:newrelic_start_time]
-        queue_time = (Thread.current[:newrelic_queue_time].to_f * 1000.0).round
+      def browser_monitoring_transaction_name
+        Thread.current[:newrelic_most_recent_transaction] || "<unknown>"
+      end
+      
+      def browser_monitoring_start_time
+        Thread.current[:newrelic_start_time]
+      end
 
-        value = ''
-        if start_time
+      def clamp_to_positive(value)
+        return 0.0 if value < 0
+        value
+      end
 
-          obf = obfuscate(transaction_name)
-          app_time = ((Time.now - start_time).to_f * 1000.0).round
+      def browser_monitoring_app_time
+        clamp_to_positive(((Time.now - browser_monitoring_start_time).to_f * 1000.0).round)
+      end
 
-          queue_time = 0.0 if queue_time < 0
-          app_time = 0.0 if app_time < 0
+      def browser_monitoring_queue_time
+        clamp_to_positive((Thread.current[:newrelic_queue_time].to_f * 1000.0).round)
+      end
 
-          value = <<-eos
-<script type="text/javascript" charset="utf-8">NREUMQ.push(["nrf2","#{beacon}","#{license_key}",#{application_id},"#{obf}",#{queue_time},#{app_time}])</script>
-eos
-        end
-        if value.respond_to?(:html_safe)
-          value.html_safe
+      def footer_js_string(beacon, license_key, application_id)
+        obfuscated_transaction_name = obfuscate(browser_monitoring_transaction_name)
+        html_safe_if_needed("<script type=\"text/javascript\" charset=\"utf-8\">NREUMQ.push([\"nrf2\",\"#{beacon}\",\"#{license_key}\",#{application_id},\"#{obfuscated_transaction_name}\",#{browser_monitoring_queue_time},#{browser_monitoring_app_time}])</script>")
+      end
+
+      def html_safe_if_needed(string)
+        if string.respond_to?(:html_safe)
+          string.html_safe
         else
-          value
+          string
         end
       end
-
-      private
-
+      
       def obfuscate(text)
         obfuscated = ""
         key_bytes = NewRelic::Agent.instance.beacon_configuration.license_bytes

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

@@ -102,9 +102,9 @@ module Agent
       #
       def end_transaction
         stack = scope_stack
-
+              
         if stack && stack.empty?
-          Thread.current[:newrelic_most_recent_transaction] = Thread.current[:newrelic_scope_name]
+          Thread::current[:newrelic_most_recent_transaction] = Thread::current[:newrelic_scope_name]
           Thread::current[:newrelic_scope_stack] = nil
           Thread::current[:newrelic_scope_name] = nil
         end

data/lib/new_relic/agent/worker_loop.rb

@@ -25,7 +25,7 @@ module NewRelic
       # that runs this worker loop.  This will run the task immediately.
       def run(period=nil, &block)
         @period = period if period
-        @next_invocation_time = Time.now
+        @next_invocation_time = (Time.now + period)
         @task = block
         while keep_running do
           now = Time.now

data/lib/new_relic/agent.rb

@@ -389,28 +389,17 @@ module NewRelic
       agent.record_transaction(response_sec, options)
     end
 
-    # PRE-RELEASE
     # Returns a Javascript string which should be injected into the very top of the response body
     #
     def browser_timing_header
       agent.browser_timing_header
     end
 
-    # PRE-RELEASE
     # Returns a Javascript string which should be injected into the very bottom of the response body
     #
     def browser_timing_footer
       agent.browser_timing_footer
     end
 
-    # FOR BACKWARD COMPATIBILITY (REMOVE BEFORE GA)
-    def browser_instrumentation_header(options={})
-      agent.browser_timing_header
-    end
-
-    # FOR BACKWARD COMPATIBILITY (REMOVE BEFORE GA)
-    def browser_instrumentation_footer(options={})
-      agent.browser_timing_footer
-    end
   end
 end

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

@@ -30,11 +30,16 @@ module NewRelic
         end
 
         def install_browser_monitoring(config)
+          return if @browser_monitoring_installed
+          @browser_monitoring_installed = true
           return if config.nil? || !config.respond_to?(:middleware) || !browser_monitoring_auto_instrument?
-
-          require 'new_relic/rack/browser_monitoring'
-          config.middleware.use NewRelic::Rack::BrowserMonitoring
-          ::RAILS_DEFAULT_LOGGER.info "Installed browser monitoring middleware"
+          begin
+            require 'new_relic/rack/browser_monitoring'
+            config.middleware.use NewRelic::Rack::BrowserMonitoring
+            log!("Installed New Relic Browser Monitoring middleware", :info)
+          rescue Exception => e
+            log!("Error installing New Relic Browser Monitoring middleware: #{e.inspect}", :error)
+          end
         end
 
         def install_developer_mode(rails_config)

data/lib/new_relic/local_environment.rb

@@ -183,7 +183,7 @@ module NewRelic
     end
 
     def working_jruby?
-      !(defined?(::JRuby) && Jruby.respond_to?(:runtime) && !JRuby.runtime.is_object_space_enabled)
+      !(defined?(::JRuby) && JRuby.respond_to?(:runtime) && !JRuby.runtime.is_object_space_enabled)
     end
 
     def find_class_in_object_space(klass)

data/lib/new_relic/recipes.rb

@@ -4,7 +4,7 @@
 #  require 'new_relic/recipes'
 # to your deploy.rb
 #
-# Defined deploy:notify_rpm which will send information about the deploy to RPM.
+# Defined deploy:notify_rpm which will send information about the deploy to New Relic.
 # The task will run on app servers except where no_release is true.
 # If it fails, it will not affect the task execution or do a rollback.
 #
@@ -12,8 +12,8 @@ make_notify_task = Proc.new do
 
   namespace :newrelic do
 
-    # on all deployments, notify RPM
-    desc "Record a deployment in New Relic RPM (rpm.newrelic.com)"
+    # on all deployments, notify New Relic
+    desc "Record a deployment in New Relic (rpm.newrelic.com)"
     task :notice_deployment, :roles => :app, :except => {:no_release => true } do
       rails_env = fetch(:newrelic_rails_env, fetch(:rails_env, "production"))
       require File.join(File.dirname(__FILE__), 'command.rb')

data/lib/new_relic/version.rb

@@ -4,7 +4,7 @@ module NewRelic
     MAJOR = 3
     MINOR = 0
     TINY  = 0
-    BUILD = 'beta1' #'0' # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
+    BUILD = 'beta2' #'0' # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
     STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end
 

data/newrelic_rpm.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{newrelic_rpm}
-  s.version = "3.0.0.beta1"
+  s.version = "3.0.0.beta2"
 
   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-04-29}
+  s.date = %q{2011-05-06}
   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
@@ -40,6 +40,7 @@ http://github.com/newrelic/rpm/tree/master.
     "lib/conditional_vendored_metric_parser.rb",
     "lib/new_relic/agent.rb",
     "lib/new_relic/agent/agent.rb",
+    "lib/new_relic/agent/beacon_configuration.rb",
     "lib/new_relic/agent/browser_monitoring.rb",
     "lib/new_relic/agent/busy_calculator.rb",
     "lib/new_relic/agent/chained_call.rb",
@@ -138,6 +139,7 @@ http://github.com/newrelic/rpm/tree/master.
     "test/new_relic/agent/agent_test_controller.rb",
     "test/new_relic/agent/agent_test_controller_test.rb",
     "test/new_relic/agent/apdex_from_server_test.rb",
+    "test/new_relic/agent/beacon_configuration_test.rb",
     "test/new_relic/agent/browser_monitoring_test.rb",
     "test/new_relic/agent/busy_calculator_test.rb",
     "test/new_relic/agent/error_collector/notice_error_test.rb",

data/test/new_relic/agent/beacon_configuration_test.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require "new_relic/agent/beacon_configuration"
+class NewRelic::Agent::BeaconConfigurationTest < Test::Unit::TestCase
+  def test_initialize_basic
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert_equal true, bc.rum_enabled
+    assert_equal '', bc.browser_timing_header
+    %w[application_id browser_monitoring_key beacon].each do |method|
+      value = bc.send(method.to_sym)
+      assert_equal nil, value, "Expected #{method} to be nil, but was #{value.inspect}"
+    end
+  end
+
+  def test_initialize_with_real_data
+    connect_data = {'browser_key' => 'a browser monitoring key', 'application_id' => 'an application id', 'beacon' => 'a beacon', 'rum_enabled' => true}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert_equal true, bc.rum_enabled
+    assert_equal 'a browser monitoring key', bc.browser_monitoring_key
+    assert_equal 'an application id', bc.application_id
+    assert_equal 'a beacon', bc.beacon
+    assert_equal 269, bc.browser_timing_header.size
+  end
+
+  def test_license_bytes_nil
+    connect_data = {}
+    NewRelic::Control.instance.expects(:license_key).returns('a' * 40).once
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert_equal([97] * 40, bc.license_bytes, 'should return the bytes of the license key')
+  end
+
+  def test_license_bytes_existing_bytes
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    bc.instance_eval { @license_bytes = [97] * 40 }
+    NewRelic::Control.instance.expects(:license_key).never
+    assert_equal([97] * 40, bc.license_bytes, "should return the cached value if it exists")
+  end
+  
+  def test_license_bytes_should_set_instance_cache
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    NewRelic::Control.instance.expects(:license_key).returns('a' * 40)
+    bc.instance_eval { @license_bytes = nil }
+    bc.license_bytes
+    assert_equal([97] * 40, bc.instance_variable_get('@license_bytes'), "should cache the license bytes for later")
+  end
+
+  def test_build_browser_timing_header_disabled
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    bc.instance_eval { @rum_enabled = false }
+    assert_equal '', bc.build_browser_timing_header(connect_data), "should not return a header when rum enabled is false"
+  end
+  
+  def test_build_browser_timing_header_enabled_but_no_key
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    bc.instance_eval { @rum_enabled = true; @browser_monitoring_key = nil }
+    assert_equal '', bc.build_browser_timing_header(connect_data), "should not return a header when browser_monitoring_key is nil"
+  end
+  
+  def test_build_browser_timing_header_enabled_checking_for_episodes_url
+    connect_data = {'episodes_url' => 'an episodes url'}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    bc.instance_eval { @rum_enabled = true; @browser_monitoring_key = 'a' * 40 }
+    assert(bc.build_browser_timing_header(connect_data).include?('an episodes url'), "should include the episodes url in the javascript")
+  end
+
+  def test_build_browser_timing_header_enabled_with_key
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    bc.instance_eval { @browser_monitoring_key = 'a browser monitoring key' }
+    bc.expects(:load_file_js).with({}).returns('load file js')
+    assert(bc.build_browser_timing_header(connect_data).include?('load file js'), "header should be generated when rum is enabled and browser monitoring key is set")
+  end
+
+  def test_basic_javascript
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    mock_data = mock('connect data')
+    bc.expects(:load_file_js).with(mock_data)
+    # should just pass through the data
+    bc.basic_javascript(mock_data)
+  end
+  
+  def test_build_browser_timing_header_should_html_safe_header
+    mock_javascript = mock('javascript')
+    connect_data = {'browser_key' => 'a' * 40}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert_equal('a' * 40, bc.instance_variable_get('@browser_monitoring_key'), "should save the key from the config")
+    bc.expects(:basic_javascript).with(connect_data).returns(mock_javascript)
+    mock_javascript.expects(:respond_to?).with(:html_safe).returns(true)
+    mock_javascript.expects(:html_safe)
+    bc.build_browser_timing_header(connect_data)
+  end
+  
+  def test_load_file_js_load_episodes_file_false
+    connect_data = {'rum.load_episodes_file' => false}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert_equal '', bc.load_file_js(connect_data), "should be empty when load episodes file is false"
+  end
+  
+  def test_load_file_js_load_episodes_file_missing
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert_equal(183, bc.load_file_js(connect_data).size, "should output the javascript when there is no configuration")
+  end
+
+  def test_load_file_js_load_episodes_file_present
+    connect_data = {'rum.load_episodes_file' => true}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert_equal(183, bc.load_file_js(connect_data).size, "should output the javascript when rum.load_episodes_file is true")
+  end
+  
+  def test_load_file_js_load_episodes_file_with_episodes_url
+    connect_data = {'episodes_url' => 'an episodes url'}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert(bc.load_file_js(connect_data).include?('an episodes url'), "should include the episodes url by default")
+  end
+end

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -12,25 +12,27 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     NewRelic::Agent.instance.instance_eval do
       @beacon_configuration = NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => true, "browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"})
     end
+    Thread.current[:newrelic_most_recent_transaction] = "MyCoolTransaction"
   end
 
   def teardown
     mocha_teardown
     Thread.current[:newrelic_start_time] = nil
     Thread.current[:newrelic_metric_frame] = nil
+    Thread.current[:newrelic_most_recent_transaction] = nil
   end
 
   def test_browser_timing_header_with_no_beacon_configuration
     NewRelic::Agent.instance.expects(:beacon_configuration).returns( nil)
     header = browser_timing_header
     assert_equal "", header
-    end
+  end
 
   def test_browser_timing_header
     header = browser_timing_header
     assert_equal "<script>var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);(function(){var d=document;var e=d.createElement(\"script\");e.type=\"text/javascript\";e.async=true;e.src=\"this_is_my_file\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})()</script>", header
   end
-
+  
   def test_browser_timing_header_with_rum_enabled_not_specified
     NewRelic::Agent.instance.expects(:beacon_configuration).at_least_once.returns( NewRelic::Agent::BeaconConfiguration.new({"browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
     header = browser_timing_header
@@ -44,12 +46,12 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   end
 
   def test_browser_timing_header_disable_all_tracing
-     header = nil
-     NewRelic::Agent.disable_all_tracing do
-       header = browser_timing_header
-     end
-     assert_equal "", header
-   end
+    header = nil
+    NewRelic::Agent.disable_all_tracing do
+      header = browser_timing_header
+    end
+    assert_equal "", header
+  end
 
   def test_browser_timing_header_disable_transaction_tracing
     header = nil
@@ -60,6 +62,7 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   end
 
   def test_browser_timing_footer
+    browser_timing_header
     NewRelic::Control.instance.expects(:license_key).returns("a" * 13)
 
     Thread.current[:newrelic_start_time] = Time.now
@@ -67,20 +70,28 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     footer = browser_timing_footer
     assert footer.include?("<script type=\"text/javascript\" charset=\"utf-8\">NREUMQ.push([\"nrf2\",")
   end
-
+  
+  def test_browser_timing_footer_without_calling_header
+    footer = browser_timing_footer
+    assert_equal "", footer
+  end
+  
   def test_browser_timing_footer_with_no_browser_key_rum_enabled
+    browser_timing_header
     NewRelic::Agent.instance.expects(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => true, "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
     footer = browser_timing_footer
     assert_equal "", footer
   end
 
   def test_browser_timing_footer_with_no_browser_key_rum_disabled
-     NewRelic::Agent.instance.expects(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => false, "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
-     footer = browser_timing_footer
-     assert_equal "", footer
-   end
+    browser_timing_header
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => false, "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
+    footer = browser_timing_footer
+    assert_equal "", footer
+  end
 
   def test_browser_timing_footer_with_rum_enabled_not_specified
+    browser_timing_header
     Thread.current[:newrelic_start_time] = Time.now
 
     license_bytes = [];
@@ -90,15 +101,18 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     NewRelic::Agent.instance.expects(:beacon_configuration).returns(config).at_least_once
     footer = browser_timing_footer
     assert footer.include?("<script type=\"text/javascript\" charset=\"utf-8\">NREUMQ.push([\"nrf2\",")
+    assert footer.include?("])</script>")
   end
 
   def test_browser_timing_footer_with_no_beacon_configuration
+    browser_timing_header
     NewRelic::Agent.instance.expects(:beacon_configuration).returns( nil)
     footer = browser_timing_footer
     assert_equal "", footer
   end
 
   def test_browser_timing_footer_with_no_start_time
+    browser_timing_header
     Thread.current[:newrelic_start_time] = nil
     NewRelic::Agent.instance.expects(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new({"browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
     footer = browser_timing_footer
@@ -107,6 +121,7 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
 
 
   def test_browser_timing_footer_disable_all_tracing
+    browser_timing_header
     footer = nil
     NewRelic::Agent.disable_all_tracing do
       footer = browser_timing_footer
@@ -115,10 +130,134 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   end
 
   def test_browser_timing_footer_disable_transaction_tracing
+    browser_timing_header
     footer = nil
     NewRelic::Agent.disable_transaction_tracing do
       footer = browser_timing_footer
     end
     assert_equal "", footer
   end
+
+  def test_browser_timing_footer_browser_monitoring_key_missing
+    fake_config = mock('beacon configuration')
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns(fake_config)
+    fake_config.expects(:nil?).returns(false)
+    fake_config.expects(:rum_enabled).returns(true)
+    fake_config.expects(:browser_monitoring_key).returns(nil)
+    self.expects(:generate_footer_js).never
+    assert_equal('', browser_timing_footer, "should not return a footer when there is no key")
+  end
+
+  def test_generate_footer_js_null_case
+    self.expects(:browser_monitoring_start_time).returns(nil)
+    assert_equal('', generate_footer_js, "should not send javascript when there is no start time")
+  end
+  
+  def test_generate_footer_js_with_start_time
+    self.expects(:browser_monitoring_start_time).returns(Time.at(100))
+    fake_bc = mock('beacon configuration')
+    fake_bc.expects(:application_id).returns(1)
+    fake_bc.expects(:beacon).returns('beacon')
+    fake_bc.expects(:browser_monitoring_key).returns('a' * 40)    
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns(fake_bc)
+    self.expects(:footer_js_string).with('beacon', 'a' * 40, 1).returns('footer js')
+    assert_equal('footer js', generate_footer_js, 'should generate and return the footer JS when there is a start time')
+  end
+
+  def test_browser_monitoring_transaction_name_basic
+    Thread.current[:newrelic_most_recent_transaction] = 'a transaction name'
+    assert_equal('a transaction name', browser_monitoring_transaction_name, "should take the value from the thread local")
+  end
+  
+  def test_browser_monitoring_transaction_name_empty
+    Thread.current[:newrelic_most_recent_transaction] = ''
+    assert_equal('', browser_monitoring_transaction_name, "should take the value even when it is empty")
+  end
+
+  def test_browser_monitoring_transaction_name_nil
+    Thread.current[:newrelic_most_recent_transaction] = nil
+    assert_equal('<unknown>', browser_monitoring_transaction_name, "should fill in a default when it is nil")
+  end
+
+  def test_browser_monitoring_start_time
+    Thread.current[:newrelic_start_time] = Time.at(100)
+    assert_equal(Time.at(100), browser_monitoring_start_time, "should take the value from the thread local")
+  end
+
+  def test_clamp_to_positive
+    assert_equal(0.0, clamp_to_positive(-1), "should clamp a negative value to zero")
+    assert_equal(1232, clamp_to_positive(1232), "should pass through the value when it is positive")
+    assert_equal(0, clamp_to_positive(0), "should not mess with zero when passing it through")
+  end
+
+  def test_browser_monitoring_app_time_nonzero
+    start = Time.now
+    self.expects(:browser_monitoring_start_time).returns(start - 1)
+    Time.expects(:now).returns(start)
+    assert_equal(1000, browser_monitoring_app_time, 'should return a rounded time')
+  end
+
+  def test_browser_monitoring_queue_time_nil
+    Thread.current[:newrelic_queue_time] = nil
+    assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is no queue time')
+  end
+  
+  def test_browser_monitoring_queue_time_zero
+    Thread.current[:newrelic_queue_time] = 0.0
+    assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is zero queue time')
+  end
+
+  def test_browser_monitoring_queue_time_ducks
+    Thread.current[:newrelic_queue_time] = 'a duck'
+    assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is an incorrect queue time')
+  end    
+
+  def test_browser_monitoring_queue_time_nonzero
+    Thread.current[:newrelic_queue_time] = 3.00002
+    assert_equal(3000, browser_monitoring_queue_time, 'should return a rounded time')
+  end
+
+  def test_footer_js_string_basic
+    beacon = ''
+    license_key = ''
+    application_id = 1
+
+    Thread.current[:newrelic_queue_time] = nil
+    # mocking this because JRuby thinks that Time.now - Time.now
+    # always takes at least 1ms
+    self.expects(:browser_monitoring_app_time).returns(0)
+    Thread.current[:newrelic_most_recent_transaction] = 'most recent transaction'
+
+    self.expects(:obfuscate).with('most recent transaction').returns('most recent transaction')
+    
+    value = footer_js_string(beacon, license_key, application_id)
+    assert_equal('<script type="text/javascript" charset="utf-8">NREUMQ.push(["nrf2","","",1,"most recent transaction",0,0])</script>', value, "should return the javascript given some default values")
+  end
+
+  def test_html_safe_if_needed_unsafed
+    string = mock('string')
+    # here to handle 1.9 encoding - we stub this out because it should
+    # be handled automatically and is outside the scope of this test
+    string.stubs(:respond_to?).with(:encoding).returns(false)
+    string.expects(:respond_to?).with(:html_safe).returns(false)
+    assert_equal(string, html_safe_if_needed(string))
+  end
+  
+  def test_html_safe_if_needed_safed
+    string = mock('string')
+    string.expects(:respond_to?).with(:html_safe).returns(true)
+    string.expects(:html_safe).returns(string)
+    # here to handle 1.9 encoding - we stub this out because it should
+    # be handled automatically and is outside the scope of this test
+    string.stubs(:respond_to?).with(:encoding).returns(false)    
+    assert_equal(string, html_safe_if_needed(string))
+  end
+
+  def test_obfuscate_basic
+    text = 'a happy piece of small text'
+    key = (1..40).to_a
+    NewRelic::Agent.instance.beacon_configuration.expects(:license_bytes).returns(key)
+    output = obfuscate(text)
+    assert_equal('YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1', output, "should output obfuscated text")
+  end
 end

data/test/new_relic/agent/busy_calculator_test.rb

@@ -68,7 +68,7 @@ class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
 
     assert_equal 1, @instance_busy.call_count
     # 3 + 6 = 9, or 90%
-    assert_in_delta 0.90, @instance_busy.total_call_time, 0.025
+    assert_in_delta 0.90, @instance_busy.total_call_time, 0.1
 
   end
   def test_dont_ignore_zero_counts

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -735,21 +735,24 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
     run_sample_trace
     run_sample_trace
-    run_sample_trace { sleep 0.06 }
+    run_sample_trace { sleep 0.1 }
     run_sample_trace
     run_sample_trace
 
     slowest = @sampler.harvest(nil, 0)[0]
-    assert slowest.duration >= 0.06, "sample duration: #{slowest.duration}"
+    assert((slowest.duration >= 0.1), "expected sample duration >= 0.1, but was: #{slowest.duration.inspect}")
+    # this assert is here to make sure the test remains valid
+    assert((slowest.duration <= 0.15), "expected sample duration <= 0.15, but was: #{slowest.duration.inspect}")
+    
 
-    run_sample_trace { sleep 0.001 }
+    run_sample_trace { sleep 0.0001 }
     not_as_slow = @sampler.harvest(slowest, 0)[0]
-    assert not_as_slow == slowest
+    assert((not_as_slow == slowest), "Should re-harvest the same transaction since it should be slower than the new transaction - expected #{slowest.inspect} but got #{not_as_slow.inspect}")
 
-    run_sample_trace { sleep 0.07 }
+    run_sample_trace { sleep 0.15 }
     new_slowest = @sampler.harvest(slowest, 0)[0]
-    assert new_slowest != slowest
-    assert new_slowest.duration >= 0.06, "Slowest duration must be > 0.06: #{new_slowest.duration}"
+    assert((new_slowest != slowest), "Should not harvest the same trace since the new one should be slower")
+    assert((new_slowest.duration >= 0.15), "Slowest duration must be >= 0.15, but was: #{new_slowest.duration.inspect}")
   end
 
 

data/test/new_relic/transaction_sample_test.rb

@@ -87,8 +87,7 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
 
         explanations.each do |explanation|
           assert_kind_of Array, explanation
-          assert_kind_of Array, explanation[0]
-          assert_equal "QUERY RESULT", explanation[0][0]
+          assert_equal "QUERY RESULT", explanation.join('')
           explain_count += 1
         end
       end

data/ui/views/layouts/newrelic_default.rhtml

@@ -2,7 +2,7 @@
     xml:lang="en" lang="en">
 <head>
 <script type="text/javascript" src="/newrelic/file/javascript/jquery-1.4.2.js"></script>
-<title>New Relic RPM Developer Mode</title>
+<title>New Relic Developer Mode</title>
 	<link href="/newrelic/file/stylesheets/style.css" 
 				media="screen" rel="stylesheet" type="text/css" />
 </head>
@@ -12,7 +12,7 @@
 		<table width="100%" height="60">
 			<tr>
 				<td valign="middle">
-					<a href='/newrelic'><img src="/newrelic/file/images/new_relic_rpm_desktop.gif" hspace="10" alt="New Relic RPM"/></a>
+					<a href='/newrelic'><img src="/newrelic/file/images/new_relic_rpm_desktop.gif" hspace="10" alt="New Relic"/></a>
 				</td>
 				<td class="top_nav" valign="bottom">
 					<ul id="navlist">

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: newrelic_rpm
 version: !ruby/object:Gem::Version 
-  hash: -1848230019
-  prerelease: true
+  hash: 62196423
+  prerelease: 6
   segments: 
   - 3
   - 0
   - 0
-  - beta1
-  version: 3.0.0.beta1
+  - beta
+  - 2
+  version: 3.0.0.beta2
 platform: ruby
 authors: 
 - Bill Kayser
@@ -17,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-29 00:00:00 -07:00
+date: 2011-05-06 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -97,6 +98,7 @@ files:
 - lib/conditional_vendored_metric_parser.rb
 - lib/new_relic/agent.rb
 - lib/new_relic/agent/agent.rb
+- lib/new_relic/agent/beacon_configuration.rb
 - lib/new_relic/agent/browser_monitoring.rb
 - lib/new_relic/agent/busy_calculator.rb
 - lib/new_relic/agent/chained_call.rb
@@ -195,6 +197,7 @@ files:
 - test/new_relic/agent/agent_test_controller.rb
 - test/new_relic/agent/agent_test_controller_test.rb
 - test/new_relic/agent/apdex_from_server_test.rb
+- test/new_relic/agent/beacon_configuration_test.rb
 - test/new_relic/agent/browser_monitoring_test.rb
 - test/new_relic/agent/busy_calculator_test.rb
 - test/new_relic/agent/error_collector/notice_error_test.rb
@@ -368,7 +371,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: New Relic Ruby Performance Monitoring Agent