sundawg_newrelic_rpm 3.5.8.1

data/test/multiverse/script/run_one

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+test/multiverse/lib/multiverse/suite.rb $PWD/test/multiverse/suites/$1 "$2" true

data/test/multiverse/script/runner

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require 'fileutils'
+require 'test/unit'
+
+module Multiverse
+  require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'multiverse', 'environment'))
+end
+
+Multiverse::Runner.run ARGV[0].to_s

data/test/multiverse/suites/active_record/Envfile

@@ -0,0 +1,13 @@
+gemfile <<-RB
+  if RUBY_VERSION == '1.8.6'
+    gem 'activerecord', '2.3.14'
+  elsif RUBY_PLATFORM == 'java'
+    gem 'activerecord-jdbcsqlite3-adapter', '1.2.2.1'
+    gem 'jdbc-sqlite3', '3.7.2'
+    gem 'activerecord'
+  else
+    gem 'activerecord'
+    gem 'sqlite3', '~> 1.3.5'
+  end
+  
+RB

data/test/multiverse/suites/active_record/ar_method_aliasing.rb

@@ -0,0 +1,94 @@
+
+require 'rubygems'
+
+require 'active_record'
+require 'test/unit'
+require 'newrelic_rpm'
+require 'multiverse/color'
+
+
+class InstrumentActiveRecordMethods < Test::Unit::TestCase
+  extend Multiverse::Color
+
+  if RUBY_VERSION >= '1.8.7'
+    if RUBY_PLATFORM == 'java'
+      require 'jdbc/sqlite3'
+      @@adapter = 'sqlite3'
+    else
+      require 'sqlite3'
+      @@adapter = 'sqlite3'
+    end
+
+    class User < ActiveRecord::Base 
+      include NewRelic::Agent::MethodTracer 
+      has_many :aliases
+
+      add_method_tracer :save!
+      add_method_tracer :persisted?
+    end
+
+    class Alias < ActiveRecord::Base
+      include NewRelic::Agent::MethodTracer
+
+      add_method_tracer :save!
+      add_method_tracer :persisted?
+      add_method_tracer :destroyed?
+    end
+    
+    def setup
+      puts "adapter : #{@@adapter}"
+      @db_connection = ActiveRecord::Base.establish_connection( :adapter => @@adapter, :database => "testdb.sqlite3")
+      ActiveRecord::Migration.class_eval do
+        @connection = @db_connection
+        create_table :users do |t|
+              t.string  :name
+        end
+
+        create_table :aliases do |t|
+            t.integer :user_id
+            t.string :aka
+        end
+      end
+    end
+
+    def teardown
+      @db_connection = ActiveRecord::Base.establish_connection( :adapter => "sqlite3", :database => "testdb.sqlite3")
+      ActiveRecord::Migration.class_eval do
+        @connection = @db_connection
+        drop_table :users
+        drop_table :aliases
+      end
+    end
+
+    def test_basic_creation
+      a_user = User.new :name => "Bob"
+      assert a_user.new_record?
+      a_user.save!
+      assert User.connected?
+      assert a_user.persisted?
+      assert a_user.id == 1 
+    end
+
+    def test_alias_collection_query_method
+      a_user = User.new :name => "Bob"
+      a_user.save!
+      a_user = User.find(1)
+      assert User.connected?
+      assert a_user.id = 1  
+
+      an_alias = Alias.new :user_id => a_user.id, :aka => "the Blob"
+      assert an_alias.new_record?
+      an_alias.save!
+      assert an_alias.persisted?
+      an_alias.destroy
+      assert an_alias.destroyed?
+    end
+
+  else
+    def test_truth
+      assert true # jruby freaks out if there are no tests defined in the test class
+    end
+    puts yellow('SKIPPED! skipped until ruby 1.8.6 compatibilites ironed out')
+  end
+end
+

data/test/multiverse/suites/active_record/config/newrelic.yml

@@ -0,0 +1,22 @@
+---
+development:
+  error_collector:
+    capture_source: true
+    enabled: true
+  apdex_t: 0.5
+  ssl: false
+  monitor_mode: true
+  license_key: bootstrap_newrelic_admin_license_key_000
+  developer_mode: false
+  app_name: test
+  host: 127.0.0.1
+  api_host: 127.0.0.1
+  port: <%= 30_000 + ($$ % 10_000) %>
+  transaction_trace:
+    record_sql: obfuscated
+    enabled: true
+    stack_trace_threshold: 0.5
+    transaction_threshold: 1.0
+  capture_params: false
+  log_level: debug
+  log_file_path: agent.log

data/test/multiverse/suites/active_record/encoding_test.rb

@@ -0,0 +1,26 @@
+# https://support.newrelic.com/tickets/2101
+# https://github.com/newrelic/rpm/pull/42
+# https://github.com/newrelic/rpm/pull/45
+require 'new_relic/agent/instrumentation/active_record'
+
+class DatabaseAdapter
+  # we patch in here
+  def log(*args)
+  end
+  include ::NewRelic::Agent::Instrumentation::ActiveRecord
+end
+
+class EncodingTest < Test::Unit::TestCase
+
+  def test_should_not_bomb_out_if_a_query_is_in_an_invalid_encoding
+    # Contains invalid UTF8 Byte
+    query = "select ICS95095010000000000083320000BS01030000004100+\xFF00000000000000000"
+    if RUBY_VERSION >= '1.9'
+      # Force the query to an invalid encoding
+      query.force_encoding 'UTF-8'
+      assert_equal false, query.valid_encoding?
+    end
+    db = DatabaseAdapter.new
+    db.send(:log, query)
+  end
+end

data/test/multiverse/suites/agent_only/Envfile

@@ -0,0 +1,9 @@
+gemfile <<-RB
+  gem 'rack'
+  gem 'rack-test'
+  if RUBY_VERSION >= '1.9.0'
+    gem 'mocha', '~> 0.13.0'
+  else
+    gem 'mocha', '< 0.13'
+  end
+RB

data/test/multiverse/suites/agent_only/audit_log_test.rb

@@ -0,0 +1,97 @@
+# RUBY-981 Audit Log
+
+require 'newrelic_rpm'
+require 'fake_collector'
+require 'mocha'
+
+class AuditLogTest < Test::Unit::TestCase
+  # Initialization
+  def setup
+    $collector ||= NewRelic::FakeCollector.new
+    $collector.reset
+    $collector.run
+
+    @string_log = StringIO.new
+    NewRelic::Agent::AuditLogger.any_instance.stubs(:ensure_log_path).returns(@string_log)
+  end
+
+  def teardown
+    $collector.reset
+  end
+
+  def audit_log_contents
+    if @contents.nil?
+      @string_log.rewind
+      @contents = @string_log.read
+    end
+    @contents
+  end
+
+  def assert_audit_log_contains(needle)
+    # Original request bodies dumped to the log have symbol keys, but once
+    # they go through a dump/load, they're strings again, so we strip
+    # double-quotes and colons from the log, and the strings we searching for.
+    regex = /[:"]/
+    needle = needle.gsub(regex, '')
+    haystack = audit_log_contents.gsub(regex, '')
+    assert(haystack.include?(needle), "Expected log to contain '#{needle}'")
+  end
+
+  # Because we don't generate a strictly machine-readable representation of
+  # request bodies for the audit log, the transformation into strings is
+  # effectively one-way. This, combined with the fact that Hash traversal order
+  # is arbitrary in Ruby 1.8.x means that it's difficult to directly assert that
+  # some object graph made it into the audit log (due to different possible 
+  # orderings of the key/value pairs in Hashes that were embedded in the request
+  # body). So, this method traverses an object graph and only makes assertions
+  # about the terminal (non-Array-or-Hash) nodes therein.
+  def assert_audit_log_contains_object(o, format)
+    if format == :json
+      assert_audit_log_contains(JSON.dump(o))
+    else
+      case o
+      when Hash
+        o.each do |k,v|
+          assert_audit_log_contains_object(v, format)
+        end
+      when Array
+        o.each do |el|
+          assert_audit_log_contains_object(el, format)
+        end
+      else
+        assert_audit_log_contains(o.inspect)
+      end
+    end
+  end
+
+  def run_agent_with_options(options)
+    NewRelic::Agent.manual_start(options)
+    yield NewRelic::Agent.agent if block_given?
+    NewRelic::Agent.shutdown
+  end
+
+  def test_logs_nothing_by_default
+    run_agent_with_options({})
+    assert_equal('', audit_log_contents)
+  end
+
+  def test_logs_nothing_when_disabled
+    run_agent_with_options({ :'audit_log.enabled' => false })
+    assert_equal('', audit_log_contents)
+  end
+
+  def test_logs_request_bodies_human_readably_ish
+    format = NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported? ? :json : :pruby
+    run_agent_with_options({ :'audit_log.enabled' => true }) do |agent|
+      agent.sql_sampler.notice_first_scope_push(nil)
+      agent.sql_sampler.notice_sql("select * from test",
+                                    "Database/test/select",
+                                    nil, 1.5)
+      agent.sql_sampler.notice_scope_empty
+      agent.send(:harvest_and_send_slowest_sql)
+    end
+    $collector.agent_data.each do |req|
+      assert_audit_log_contains_object(req.body, format)
+    end
+  end
+end

data/test/multiverse/suites/agent_only/config/newrelic.yml

@@ -0,0 +1,23 @@
+---
+development:
+  error_collector:
+    capture_source: true
+    enabled: true
+  apdex_t: 0.24
+  ssl: false
+  monitor_mode: true
+  license_key: bootstrap_newrelic_admin_license_key_000
+  developer_mode: false
+  app_name: test
+  host: 127.0.0.1
+  api_host: 127.0.0.1
+  port: <%= 30_000 + ($$ % 10_000) %>
+  transaction_tracer:
+    record_sql: obfuscated
+    enabled: true
+    stack_trace_threshold: 0.5
+  capture_params: false
+  log_level: debug
+  log_file_path: agent.log
+  browser_monitoring:
+    auto_instrument: true

data/test/multiverse/suites/agent_only/cross_application_tracing_test.rb

@@ -0,0 +1,56 @@
+require 'rack/test'
+require 'fake_collector'
+require './testing_app'
+
+class CrossProcessTest < Test::Unit::TestCase
+
+  # Important because the hooks are global that we only wire one AgentHooks up
+  @@app = TestingApp.new
+  @@wrapper_app = NewRelic::Rack::AgentHooks.new(@@app)
+
+  def setup
+    $collector ||= NewRelic::FakeCollector.new
+    $collector.reset
+    $collector.mock['connect'] = [200, {'return_value' => {"agent_run_id" => 666 }}]
+    $collector.run
+
+    NewRelic::Agent.manual_start(
+      :cross_process_id => "boo",
+      :encoding_key => "\0",
+      :trusted_account_ids => [1])
+
+    NewRelic::Agent.instance.events.notify(:finished_configuring) 
+
+    @@app.reset_headers
+    @@app.response = "<html><head><title>W00t!</title></head><body><p>Hello World</p></body></html>"
+  end
+
+  def teardown
+    NewRelic::Agent.shutdown
+  end
+
+  include Rack::Test::Methods
+
+  def app
+    @@wrapper_app
+  end
+
+  def test_cross_app_doesnt_modify_without_header
+    get '/'
+    assert_nil last_response.headers["X-NewRelic-App-Data"]
+  end
+
+  def test_cross_app_doesnt_modify_with_invalid_header
+    get '/', nil, {'X-NewRelic-ID' => Base64.encode64('otherjunk')}
+    assert_nil last_response.headers["X-NewRelic-App-Data"]
+  end
+
+  def test_cross_app_writes_out_information
+    get '/', nil, {'X-NewRelic-ID' => Base64.encode64('1#234')}
+    assert_not_nil last_response.headers["X-NewRelic-App-Data"]
+
+    metric = NewRelic::Agent.instance.stats_engine.lookup_stats('ClientApplication/1#234/all')
+    assert_equal 1, metric.call_count
+  end
+end
+

data/test/multiverse/suites/agent_only/http_response_code_test.rb

@@ -0,0 +1,53 @@
+# https://newrelic.atlassian.net/browse/RUBY-765
+require 'fake_collector'
+
+class HttpResponseCodeTest < Test::Unit::TestCase
+  def setup
+    $collector ||= NewRelic::FakeCollector.new
+    $collector.reset
+    $collector.run
+    NewRelic::Agent.manual_start(:send_data_on_exit => false)
+    @agent = NewRelic::Agent.instance
+  end
+
+  def teardown
+    $collector.reset
+    NewRelic::Agent.shutdown
+  end
+
+  def test_request_entity_too_large
+    $collector.mock['metric_data'] = [413, {'exception' => {'error_type' => 'RuntimeError', 'message' => 'too much'}}]
+
+    @agent.stats_engine.get_stats_no_scope('Custom/too_big') \
+      .record_data_point(1)
+    assert_equal 1, @agent.stats_engine \
+      .get_stats_no_scope('Custom/too_big').call_count
+
+    @agent.send(:harvest_and_send_timeslice_data)
+
+    # make sure the data gets thrown away without crashing
+    assert_equal 0, @agent.stats_engine \
+      .get_stats_no_scope('Custom/too_big').call_count
+
+    # make sure we actually talked to the collector
+    assert_equal(1, $collector.agent_data.select{|x| x.action == 'metric_data'}.size)
+  end
+
+  def test_unsupported_media_type
+    $collector.mock['metric_data'] = [415, {'exception' => {'error_type' => 'RuntimeError', 'message' => 'looks bad'}}]
+
+    @agent.stats_engine.get_stats_no_scope('Custom/too_big') \
+      .record_data_point(1)
+    assert_equal 1, @agent.stats_engine \
+      .get_stats_no_scope('Custom/too_big').call_count
+
+    @agent.send(:harvest_and_send_timeslice_data)
+
+    # make sure the data gets thrown away without crashing
+    assert_equal 0, @agent.stats_engine \
+      .get_stats_no_scope('Custom/too_big').call_count
+
+    # make sure we actually talked to the collector
+    assert_equal(1, $collector.agent_data.select{|x| x.action == 'metric_data'}.size)
+  end
+end

data/test/multiverse/suites/agent_only/key_transactions_test.rb

@@ -0,0 +1,66 @@
+class KeyTransactionsTest < Test::Unit::TestCase
+  class TestWidget
+    include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+    def key_txn
+      sleep 0.05
+    end
+    add_transaction_tracer :key_txn
+
+    def other_txn
+      sleep 0.05
+    end
+    add_transaction_tracer :other_txn
+  end
+
+  def setup
+    $collector ||= NewRelic::FakeCollector.new
+    $collector.reset
+    key_apdex_config = { 'Controller/KeyTransactionsTest::TestWidget/key_txn' => 0.01 }
+    $collector.mock['connect'] = [200, {'return_value' => {
+                                      "agent_run_id" => 666,
+                            'web_transactions_apdex' => key_apdex_config,
+                                           'apdex_t' => 0.1
+                                    }}]
+    $collector.run
+
+    NewRelic::Agent.manual_start(:sync_startup => true,
+                                 :force_reconnect => true)
+  end
+
+  def teardown
+    NewRelic::Agent.shutdown
+  end
+
+  SATISFYING = 0
+  TOLERATING = 1
+  FAILING    = 2
+
+  def test_applied_correct_apdex_t_to_key_txn
+    TestWidget.new.key_txn
+    NewRelic::Agent.instance.send(:harvest_and_send_timeslice_data)
+
+    stats = $collector.reported_stats_for_metric('Apdex')[0]
+    assert_equal 1.0, stats[FAILING]
+  end
+
+  def test_applied_correct_apdex_t_to_regular_txn
+    TestWidget.new.other_txn
+    NewRelic::Agent.instance.send(:harvest_and_send_timeslice_data)
+
+    stats = $collector.reported_stats_for_metric('Apdex')[0]
+    assert_equal 1.0, stats[SATISFYING]
+  end
+
+  def test_applied_correct_tt_theshold
+    TestWidget.new.key_txn
+    TestWidget.new.other_txn
+
+    NewRelic::Agent.instance.send(:harvest_and_send_slowest_sample)
+
+    traces = $collector.calls_for('transaction_sample_data')
+    assert_equal 1, traces.size
+    assert_equal('Controller/KeyTransactionsTest::TestWidget/key_txn',
+                 traces[0].metric_name)
+  end
+end