newrelic_rpm 3.6.6.147 → 3.6.7.152

data/test/multiverse/suites/rails/error_tracing_test.rb

@@ -39,6 +39,17 @@ class ErrorController < ApplicationController
     raise ServerIgnoredError.new('this is a server ignored error')
   end
 
+  def frozen_error
+    e = RuntimeError.new("frozen errors make a refreshing treat on a hot summer day")
+    e.freeze
+    raise e
+  end
+
+  def string_noticed_error
+    NewRelic::Agent.notice_error("trilobites died out millions of years ago")
+    render :text => 'trilobites'
+  end
+
   def noticed_error
     newrelic_notice_error(RuntimeError.new('this error should be noticed'))
     render :text => "Shoulda noticed an error"
@@ -102,6 +113,18 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
                                'Controller/error/noticed_error')
   end
 
+  def test_should_capture_frozen_errors
+    get '/error/frozen_error'
+    assert_error_reported_once("frozen errors make a refreshing treat on a hot summer day",
+                               "Controller/error/frozen_error")
+  end
+
+  def test_should_capture_string_noticed_errors
+    get '/error/string_noticed_error'
+    assert_error_reported_once("trilobites died out millions of years ago",
+                               "Controller/error/string_noticed_error")
+  end
+
   # Important choice of controllor_error, since this goes through both the
   # transaction and the rack error collector, so risks multiple counting!
   def test_should_capture_multiple_errors
@@ -109,17 +132,17 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
       get '/error/controller_error'
     end
 
-    assert_errors_reported('this is an uncaught controller error', 20, 40)
+    assert_errors_reported('this is an uncaught controller error', 20, 40, nil, 40)
   end
 
   def test_should_capture_manually_noticed_error
     NewRelic::Agent.notice_error(RuntimeError.new('this is a noticed error'))
-    assert_error_reported_once('this is a noticed error')
+    assert_error_reported_once('this is a noticed error', nil, nil)
   end
 
   def test_should_capture_routing_error
     get '/bad_route'
-    assert_error_reported_once('this is an uncaught routing error')
+    assert_error_reported_once('this is an uncaught routing error', nil, nil)
   end
 
   def test_should_apply_parameter_filtering
@@ -171,28 +194,32 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
 
   def test_should_capture_errors_raised_in_middleware_before_call
     get '/error/middleware_error/before'
-    assert_error_reported_once('middleware error')
+    assert_error_reported_once('middleware error', nil, nil)
   end
 
   def test_should_capture_errors_raised_in_middleware_after_call
     get '/error/middleware_error/after'
-    assert_error_reported_once('middleware error')
+    assert_error_reported_once('middleware error', nil, nil)
   end
 
  protected
 
-  def assert_errors_reported(message, queued_count, total_count=queued_count, txn_name=nil)
+  def assert_errors_reported(message, queued_count, total_count=queued_count, txn_name=nil, apdex_f=1)
     expected = { :call_count => total_count }
     assert_metrics_recorded("Errors/all" => expected)
     assert_metrics_recorded("Errors/#{txn_name}" => expected) if txn_name
 
+    unless apdex_f.nil?
+      assert_metrics_recorded("Apdex" => { :apdex_f => apdex_f })
+    end
+
     assert_equal(queued_count,
       @error_collector.errors.select{|error| error.message == message}.size,
       "Wrong number of errors with message #{message.inspect} found")
   end
 
-  def assert_error_reported_once(message, txn_name=nil)
-    assert_errors_reported(message, 1, 1, txn_name)
+  def assert_error_reported_once(message, txn_name=nil, apdex_f=1)
+    assert_errors_reported(message, 1, 1, txn_name, apdex_f)
   end
 end
 

data/test/multiverse/suites/rails/ignore_test.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+# https://newrelic.atlassian.net/browse/RUBY-927
+
+require 'rails/test_help'
+require './app'
+require 'multiverse_helpers'
+
+class IgnoredController < ApplicationController
+  include Rails.application.routes.url_helpers
+
+  newrelic_ignore :only => :action_to_ignore
+  newrelic_ignore_apdex :only => :action_to_ignore_apdex
+
+  def action_to_ignore
+    render :text => "Ignore this"
+  end
+
+  def action_to_ignore_apdex
+    render :text => "This too"
+  end
+end
+
+class IgnoredActionsTest < ActionDispatch::IntegrationTest
+
+  include MultiverseHelpers
+
+  setup_and_teardown_agent
+
+  def after_setup
+    # Make sure we've got a blank slate for doing easier metric comparisons
+    NewRelic::Agent.instance.reset_stats
+  end
+
+  def test_metric__ignore
+    get 'ignored/action_to_ignore'
+    assert_metrics_recorded_exclusive([])
+  end
+
+  def test_metric__ignore_apdex
+    get 'ignored/action_to_ignore_apdex'
+    assert_metrics_recorded(["Controller/ignored/action_to_ignore_apdex"])
+    assert_metrics_not_recorded(["Apdex"])
+  end
+
+end

data/test/multiverse/suites/rails/mongrel_queue_depth_test.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+# https://newrelic.atlassian.net/browse/RUBY-927
+
+# Mongrel is only supported on older versions, so don't check for queue depth
+if Rails::VERSION::MAJOR.to_i < 4
+
+require 'rails/test_help'
+require './app'
+require 'multiverse_helpers'
+require 'ostruct'
+
+class MongrelController < ApplicationController
+  include Rails.application.routes.url_helpers
+
+  def deep
+    respond_to do |format|
+      format.html { render :text => "<html><head></head><body>Deep</body></html>" }
+    end
+  end
+end
+
+class MongrelQueueDepthTest < ActionDispatch::IntegrationTest
+
+  include MultiverseHelpers
+
+  setup_and_teardown_agent(:beacon => "beacon", :browser_key => "key")
+
+  def test_mongrel_queue
+    mongrel = OpenStruct.new(:workers => OpenStruct.new(:list => OpenStruct.new(:length => "10")))
+    NewRelic::Control.instance.local_env.mongrel = mongrel
+
+    get('/mongrel/deep')
+
+    assert_metrics_recorded(['HttpDispatcher'])
+    assert_metrics_recorded('Mongrel/Queue Length' => {:call_count => 1, :total_call_time => 9.0})
+    assert_metrics_not_recorded(['WebFrontend/Mongrel/Average Queue Time'])
+  end
+
+end
+
+end

data/test/multiverse/suites/sequel/sequel_test.rb

@@ -31,4 +31,15 @@ class SequelTest < MiniTest::Unit::TestCase
     assert u.is_a?( User ), "#{u} isn't a User"
   end
 
+  # The oldest version of Sequel that we test against does not define a VERSION
+  # constant, or the in_transaction? method, so skip this test for that version.
+  if DB.respond_to?(:in_transaction?)
+    def test_should_not_clobber_in_transaction
+      require 'newrelic_rpm'
+
+      DB.transaction do
+        assert_equal(true, DB.in_transaction?)
+      end
+    end
+  end
 end

data/test/multiverse/suites/sinatra/ignoring_test.rb

@@ -129,7 +129,7 @@ class SinatraIgnoreTest < SinatraTestCase
   def test_ignore_enduser
     get_and_assert_ok '/no_enduser'
 
-    assert NewRelic::Agent::TransactionInfo.get.ignore_end_user?
+    assert NewRelic::Agent::TransactionState.get.request_ignore_enduser
     assert_metrics_recorded([
       "Controller/Sinatra/#{app_name}/GET no_enduser",
       "Apdex/Sinatra/#{app_name}/GET no_enduser"])
@@ -183,6 +183,6 @@ class SinatraIgnoreApdexAndEndUserTest < SinatraTestCase
 
   def test_ignores_enduser
     get_and_assert_ok '/'
-    assert NewRelic::Agent::TransactionInfo.get.ignore_end_user?
+    assert NewRelic::Agent::TransactionState.get.request_ignore_enduser
   end
 end

data/test/multiverse/suites/typhoeus/Envfile

@@ -1,5 +1,12 @@
-suite_condition("Typhoeus not supported in 1.8.6") do
-  RUBY_VERSION != '1.8.6'
+suite_condition("Typhoeus not supported in 1.8.6 and excluded on 1.8.7 non-REE") do
+
+  # Under Ruby 1.8.7 (but not REE), there are persistent segfaults with Typhoeus
+  # and the Ruby agent. This predated our Typhoeus instrumentation, but given
+  # usage levels and obscurity of the issue, it isn't worth deeper digging.
+  # Just use REE, or better yet >= 1.9
+
+  (RUBY_VERSION != '1.8.6') &&
+  (RUBY_VERSION != '1.8.7' || RUBY_DESCRIPTION =~ /Enterprise/)
 end
 
 gemfile <<-RB

data/test/multiverse/suites/typhoeus/typhoeus_test.rb

@@ -30,8 +30,9 @@ if NewRelic::Agent::Instrumentation::TyphoeusTracing.is_supported_version?
 
     # We use the Typhoeus::Request rather than right on Typhoeus to support
     # prior to convenience methods being added on the top-level module (0.5.x)
-    def get_response(url=nil)
-      Typhoeus::Request.get(url || default_url, ssl_option)
+    def get_response(url=nil, headers=nil)
+      options = {:headers => headers}.merge(ssl_option)
+      Typhoeus::Request.get(url || default_url, options)
     end
 
     def head_response

data/test/new_relic/agent/agent/start_test.rb

@@ -51,10 +51,11 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   end
 
   def test_check_config_and_start_agent_normal
+
     self.expects(:generate_environment_report)
     self.expects(:start_worker_thread)
     self.expects(:install_exit_handler)
-    with_config(:sync_startup => false, :monitor_mode => true, :license_key => 'a' * 40) do
+    with_config(:dispatcher => 'test', :sync_startup => false, :monitor_mode => true, :license_key => 'a' * 40) do
       check_config_and_start_agent
     end
   end
@@ -64,7 +65,7 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
     self.expects(:connect_in_foreground)
     self.expects(:start_worker_thread)
     self.expects(:install_exit_handler)
-    with_config(:sync_startup => true, :monitor_mode => true, :license_key => 'a' * 40) do
+    with_config(:dispatcher => 'test', :sync_startup => true, :monitor_mode => true, :license_key => 'a' * 40) do
       check_config_and_start_agent
     end
   end
@@ -172,26 +173,6 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
     end
   end
 
-  def test_log_unless_positive
-    # should not log
-    assert log_unless(true, :warn, "DURRR")
-  end
-
-  def test_log_unless_negative
-    # should log
-    expects_logging(:warn, "DURRR")
-    assert !log_unless(false, :warn, "DURRR")
-  end
-
-  def test_log_if_positive
-    expects_logging(:warn, "WHEE")
-    assert log_if(true, :warn, "WHEE")
-  end
-
-  def test_log_if_negative
-    assert !log_if(false, :warn, "WHEE")
-  end
-
   private
 
   def mocked_control

data/test/new_relic/agent/agent_test.rb

@@ -3,7 +3,7 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
-require 'new_relic/agent/thread_profiler'
+require 'new_relic/agent/commands/thread_profiler'
 
 module NewRelic
   module Agent
@@ -13,6 +13,7 @@ module NewRelic
         super
         @agent = NewRelic::Agent::Agent.new
         @agent.service = default_service
+        @agent.agent_command_router.stubs(:service).returns(@agent.service)
         @agent.stubs(:start_worker_thread)
       end
 
@@ -21,7 +22,7 @@ module NewRelic
       #
 
       def with_profile(opts)
-        profile = NewRelic::Agent::ThreadProfile.new(-1, 0, 0, true)
+        profile = NewRelic::Agent::Threading::ThreadProfile.new(create_agent_command)
         profile.aggregate(["chunky.rb:42:in `bacon'"], profile.traces[:other])
         profile.instance_variable_set(:@finished, opts[:finished])
 
@@ -173,9 +174,9 @@ module NewRelic
         assert_equal([], @agent.send(:harvest_errors), 'should return errors')
       end
 
-      def test_check_for_agent_commands
+      def test_handle_for_agent_commands
         @agent.service.expects(:get_agent_commands).returns([]).once
-        @agent.send :check_for_agent_commands
+        @agent.send :handle_agent_commands
       end
 
       def test_merge_data_from_empty
@@ -253,7 +254,7 @@ module NewRelic
 
         # This method should NOT increment error counts, since that has already
         # been counted in the child
-        assert_equal 0, NewRelic::Agent.get_stats("Errors/all").call_count
+        assert_equal 0, @agent.stats_engine.get_stats("Errors/all").call_count
       end
 
       def test_connect_retries_on_timeout

data/test/new_relic/agent/autostart_test.rb

@@ -14,7 +14,7 @@ class AutostartTest < Test::Unit::TestCase
   if defined?(::Rails)
     def test_agent_wont_autostart_if_RAILS_CONSOLE_constant_is_defined
       assert !defined?(::Rails::Console), "precondition: Rails::Console shouldn't be defined"
-      Rails.const_set(:Console, true)
+      Rails.const_set(:Console, Class.new)
       assert ! ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't autostart in Rails Console session"
     ensure
       Rails.send(:remove_const, :Console)
@@ -23,6 +23,13 @@ class AutostartTest < Test::Unit::TestCase
     puts "Skipping tests in #{__FILE__} because Rails is unavailable"
   end
 
+  def test_agent_will_autostart_if_global_CONSOLE_constant_is_defined
+    Object.const_set(:Console, Class.new)
+    assert ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't find ::Console"
+  ensure
+    Object.send(:remove_const, :Console)
+  end
+
   def test_agent_wont_start_if_dollar_0_is_irb
     @orig_dollar_0, $0 = $0, '/foo/bar/irb'
     assert ! ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't autostart when process is invoked by irb"
@@ -68,4 +75,35 @@ class AutostartTest < Test::Unit::TestCase
       assert ! ::NewRelic::Agent::Autostart.agent_should_start?, "Agent shouldn't during blacklisted rake task"
     end
   end
+
+  module ::Outer
+    class Included
+    end
+  end
+
+  class ::Excluded
+  end
+
+  module ::ContainsAnObject
+    class ContainedObject
+    end
+  end
+
+  def test_should_look_within_module
+    assert_equal ::Outer::Included, NewRelic::Agent::Autostart.constant_is_defined?("Outer::Included")
+  end
+
+  def test_shouldnt_look_outside_module_for_class
+    assert_equal false, NewRelic::Agent::Autostart.constant_is_defined?("Outer::Excluded")
+  end
+
+  def test_shouldnt_look_outside_module_for_module
+    assert_equal false, NewRelic::Agent::Autostart.constant_is_defined?("Outer::Outer")
+  end
+
+  def test_should_allow_object_in_module_names
+    assert_equal ::ContainsAnObject::ContainedObject,
+                  NewRelic::Agent::Autostart.constant_is_defined?("ContainsAnObject::ContainedObject")
+  end
+
 end

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -5,7 +5,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 require "new_relic/agent/browser_monitoring"
 require "new_relic/rack/browser_monitoring"
-require 'ostruct'
+require 'base64'
 
 class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   include NewRelic::Agent::BrowserMonitoring
@@ -28,10 +28,15 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     NewRelic::Agent.instance.instance_eval do
       @beacon_configuration = NewRelic::Agent::BeaconConfiguration.new
     end
+
+    # By default we expect our transaction to have a start time
+    # All sorts of basics don't output without this setup initially
+    NewRelic::Agent::TransactionState.reset(nil)
+    current_transaction.start_time = Time.now
   end
 
   def teardown
-    NewRelic::Agent::TransactionInfo.clear
+    NewRelic::Agent::TransactionState.clear
     NewRelic::Agent.config.remove_config(@config)
     mocha_teardown
   end
@@ -40,7 +45,7 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     assert NewRelic::Agent.config[:'browser_monitoring.auto_instrument']
   end
 
-  def test_browser_monitoring_start_time_is_reset_each_request_when_auto_instrument_is_disabled
+  def test_start_time_reset_each_request_when_auto_instrument_is_disabled
     controller = Object.new
     def controller.perform_action_without_newrelic_trace(method, options={});
       # noop; instrument me
@@ -51,9 +56,10 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
 
     with_config(:'browser_monitoring.auto_instrument' => false) do
       controller.perform_action_with_newrelic_trace(:index)
-      first_request_start_time = controller.send(:browser_monitoring_start_time)
+      first_request_start_time = current_transaction.start_time
+
       controller.perform_action_with_newrelic_trace(:index)
-      second_request_start_time = controller.send(:browser_monitoring_start_time)
+      second_request_start_time = current_transaction.start_time
 
       # assert that these aren't the same time object
       # the start time should be reinitialized each request to the controller
@@ -104,9 +110,10 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
 
   def test_browser_timing_footer
     with_config(:license_key => 'a' * 13) do
+      NewRelic::Agent::TransactionState.reset
       browser_timing_header
       footer = browser_timing_footer
-      snippet = '<script type="text/javascript">if (!NREUMQ.f) { NREUMQ.f=function() {
+      snippet = '<script type="text/javascript">if (typeof NREUMQ !== "undefined") { if (!NREUMQ.f) { NREUMQ.f=function() {
 NREUMQ.push(["load",new Date().getTime()]);
 var e=document.createElement("script");'
       assert(footer.include?(snippet),
@@ -134,6 +141,7 @@ var e=document.createElement("script");'
   end
 
   def test_browser_timing_footer_with_rum_enabled_not_specified
+    NewRelic::Agent::TransactionState.reset
     browser_timing_header
 
     license_bytes = [];
@@ -142,10 +150,10 @@ var e=document.createElement("script");'
     config.expects(:license_bytes).returns(license_bytes).at_least_once
     NewRelic::Agent.instance.stubs(:beacon_configuration).returns(config).at_least_once
     footer = browser_timing_footer
-    beginning_snippet = '<script type="text/javascript">if (!NREUMQ.f) { NREUMQ.f=function() {
+    beginning_snippet = '<script type="text/javascript">if (typeof NREUMQ !== "undefined") { if (!NREUMQ.f) { NREUMQ.f=function() {
 NREUMQ.push(["load",new Date().getTime()]);
 var e=document.createElement("script");'
-    ending_snippet = "]);</script>"
+    ending_snippet = "]);}</script>"
     assert(footer.include?(beginning_snippet),
            "expected footer to include beginning snippet: #{beginning_snippet}, but was #{footer}")
     assert(footer.include?(ending_snippet),
@@ -189,13 +197,12 @@ var e=document.createElement("script");'
   end
 
   def test_generate_footer_js_null_case
-    self.expects(:browser_monitoring_start_time).returns(nil)
+    current_transaction.start_time = nil
     assert_equal('', generate_footer_js(NewRelic::Agent.instance.beacon_configuration), "should not send javascript when there is no start time")
   end
 
   def test_generate_footer_js_with_start_time
     with_config(:browser_key => 'a' * 40) do
-      self.expects(:browser_monitoring_start_time).returns(Time.at(100))
       fake_bc = mock('beacon configuration')
       NewRelic::Agent.instance.stubs(:beacon_configuration).returns(fake_bc)
       self.expects(:footer_js_string).with(NewRelic::Agent.instance.beacon_configuration).returns('footer js')
@@ -205,20 +212,18 @@ var e=document.createElement("script");'
   end
 
   def test_browser_monitoring_transaction_name_basic
-    mock = stub_everything('transaction info')
-    NewRelic::Agent::TransactionInfo.set(mock)
     txn = NewRelic::Agent::Transaction.new
     txn.name = 'a transaction name'
-    mock.stubs(:transaction).returns(txn)
+    NewRelic::Agent::TransactionState.get.transaction = txn
 
     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
-    mock = mock('transaction sample')
-    NewRelic::Agent::TransactionInfo.set(mock)
+    txn = NewRelic::Agent::Transaction.new
+    txn.name = ''
+    NewRelic::Agent::TransactionState.get.transaction = txn
 
-    mock.stubs(:transaction).returns(stub(:name => ''))
     assert_equal('', browser_monitoring_transaction_name, "should take the value even when it is empty")
   end
 
@@ -237,78 +242,19 @@ var e=document.createElement("script");'
     end
   end
 
-  def test_browser_monitoring_start_time
-    mock = mock('transaction info')
-
-    NewRelic::Agent::TransactionInfo.set(mock)
-
-    mock.stubs(:start_time).returns(Time.at(100))
-    mock.stubs(:guid).returns('ABC')
-    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.stubs(:now).returns(start)
-    assert_equal(1000, browser_monitoring_app_time, 'should return a rounded time')
-  end
-
-  def test_browser_monitoring_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
-    in_transaction do
-      NewRelic::Agent::Transaction.current.expects(:queue_time).returns(0.0)
-      assert_equal(0.0, browser_monitoring_queue_time,
-                   'should return zero when there is zero queue time')
-    end
-  end
-
-  def test_browser_monitoring_queue_time_ducks
-    in_transaction do
-      NewRelic::Agent::Transaction.current.expects(:queue_time) \
-        .returns('a duck')
-      assert_equal(0.0, browser_monitoring_queue_time,
-                   'should return zero when there is an incorrect queue time')
-    end
-  end
-
-  def test_browser_monitoring_queue_time_nonzero
-    in_transaction do
-      NewRelic::Agent::Transaction.current.expects(:queue_time) \
-        .returns(3.00002)
-      assert_equal(3000, browser_monitoring_queue_time,
-                   'should return a rounded time')
-    end
-  end
-
   def test_footer_js_string_basic
-    # mocking this because JRuby thinks that Time.now - Time.now
-    # always takes at least 1ms
-    self.expects(:browser_monitoring_app_time).returns(0)
+    freeze_time
     in_transaction do
       txn = NewRelic::Agent::Transaction.current
       user_attributes = {:user => "user", :account => "account", :product => "product"}
-      txn.expects(:user_attributes).returns(user_attributes).at_least_once
-      txn.expects(:queue_time).returns(0)
+      txn.stubs(:user_attributes).returns(user_attributes)
+      txn.stubs(:queue_time).returns(0)
+      txn.stubs(:start_time).returns(Time.now - 10)
       txn.name = 'most recent transaction'
 
-      sample = stub_everything('transaction info',
-                               :start_time => Time.at(100),
-                               :guid => 'ABC',
-                               :transaction => txn,
-                               :include_guid? => true,
-                               :duration => 12.0,
-                               :token => '0123456789ABCDEF')
-      NewRelic::Agent::TransactionInfo.set(sample)
+      NewRelic::Agent::TransactionState.get.reset(nil)
+      NewRelic::Agent::TransactionState.get.request_token = '0123456789ABCDEF'
+      NewRelic::Agent::TransactionState.get.request_guid = 'ABC'
 
       self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'most recent transaction').returns('most recent transaction')
       self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'user').returns('user')
@@ -316,7 +262,7 @@ var e=document.createElement("script");'
       self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'product').returns('product')
 
       value = footer_js_string(NewRelic::Agent.instance.beacon_configuration)
-      assert_equal(%'<script type="text/javascript">if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push(["load",new Date().getTime()]);\nvar e=document.createElement("script");\ne.type="text/javascript";\ne.src=(("http:"===document.location.protocol)?"http:":"https:") + "//" +\n  "this_is_my_file";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\nNREUMQ.push(["nrfj","beacon","browserKey","5, 6","most recent transaction",0,0,new Date().getTime(),"ABC","0123456789ABCDEF","user","account","product"]);</script>', value, "should return the javascript given some default values")
+      assert_equal(%'<script type="text/javascript">if (typeof NREUMQ !== "undefined") { if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push(["load",new Date().getTime()]);\nvar e=document.createElement("script");\ne.type="text/javascript";\ne.src=(("http:"===document.location.protocol)?"http:":"https:") + "//" +\n  "this_is_my_file";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\nNREUMQ.push(["nrfj","beacon","browserKey","5, 6","most recent transaction",0,10000,new Date().getTime(),"ABC","0123456789ABCDEF","user","account","product"]);}</script>', value, "should return the javascript given some default values")
     end
   end
 
@@ -355,6 +301,17 @@ var e=document.createElement("script");'
     assert_equal('YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1YyNsZHZ3cSl6YmluZCJsYiV1amllZit4aHl2YiRtZ3d4cCp7ZWhiZyNrYyZ0ZWhmZyx5ZHp3ZSVuZnh5cyt8ZGRhZiRqYCd7ZGtnYC11Z3twZCZvaXl6cix9aGdgYSVpYSh6Z2pgYSF2Znxx', output, "should output obfuscated text")
   end
 
+  def test_obfuscate_utf8
+    text = "foooooééoooo - blah"
+    key = (1..40).to_a
+    NewRelic::Agent.instance.beacon_configuration.expects(:license_bytes).returns(key).at_least_once
+    output = obfuscate(NewRelic::Agent.instance.beacon_configuration, text)
+    assert_equal('Z21sa2ppxKHKo2RjYm4iLiRnamZg', output, "should output obfuscated text")
+
+    unoutput = obfuscate(NewRelic::Agent.instance.beacon_configuration, Base64.decode64(output))
+    assert_equal Base64.encode64(text).gsub("\n", ''), unoutput
+  end
+
   def test_no_mobile_response_header_if_no_mobile_request_header_given
     request = Rack::Request.new({})
     response = Rack::Response.new
@@ -390,7 +347,7 @@ var e=document.createElement("script");'
     response = mobile_transaction
     txn_name = obfuscate(NewRelic::Agent.instance.beacon_configuration,
                          browser_monitoring_transaction_name)
-    expected_payload = %|["5, 6","#{txn_name}",#{browser_monitoring_queue_time},#{browser_monitoring_app_time}]|
+    expected_payload = %|["5, 6","#{txn_name}",#{current_timings.queue_time_in_millis},#{current_timings.app_time_in_millis}]|
 
     assert_equal expected_payload, response['X-NewRelic-App-Server-Metrics'].strip
   end
@@ -410,10 +367,8 @@ var e=document.createElement("script");'
     response = Rack::Response.new
     txn = NewRelic::Agent::Transaction.new
     txn.name = 'a transaction name'
-    txn_data = OpenStruct.new(:transaction => txn,
-                              :start_time => 5,
-                              :force_persist_sample? => false)
-    NewRelic::Agent::TransactionInfo.set(txn_data)
+    txn.start_time = Time.at(5)
+    NewRelic::Agent::TransactionState.get.transaction = txn
     NewRelic::Agent::BrowserMonitoring.insert_mobile_response_header(request, response)
     response
   end