RubyGems - newrelic_rpm - Versions diffs - 4.1.0.333 → 4.2.0.334 - Mend

newrelic_rpm 4.1.0.333 → 4.2.0.334

Files changed (788) hide show

data/test/performance/suites/queue_time.rb DELETED Viewed

@@ -1,21 +0,0 @@
-# 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.
-class QueueTimePerfTests < Performance::TestCase
-  def setup
-    @headers = [
-      { 'HTTP_X_REQUEST_START' => "t=1409849996.2152882" },
-      { 'HTTP_X_REQUEST_START' => "t=1409850011020.236"  },
-      { 'HTTP_X_REQUEST_START' => "t=1409850011020236.0" },
-    ]
-  end
-  def test_queue_time_parsing
-    measure do
-      @headers.each do |h|
-        NewRelic::Agent::Instrumentation::QueueTime.parse_frontend_timestamp(h)
-      end
-    end
-  end
-end

data/test/performance/suites/rack_middleware.rb DELETED Viewed

@@ -1,134 +0,0 @@
-# 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.
-require 'rack'
-class RackMiddleware < Performance::TestCase
-  class TestMiddleware
-    def initialize(app)
-      @app = app
-    end
-    def call(env)
-      @app.call(env)
-    end
-  end
-  # We want 10 middlewares each with different names so that we end up with
-  # different metric names for each one. This is more realistic than using the
-  # same name 10 times.
-  class TestMiddlewareA < TestMiddleware; def call(e); @app.call(e); end; end
-  class TestMiddlewareB < TestMiddleware; def call(e); @app.call(e); end; end
-  class TestMiddlewareC < TestMiddleware; def call(e); @app.call(e); end; end
-  class TestMiddlewareD < TestMiddleware; def call(e); @app.call(e); end; end
-  class TestMiddlewareE < TestMiddleware; def call(e); @app.call(e); end; end
-  class TestMiddlewareF < TestMiddleware; def call(e); @app.call(e); end; end
-  class TestMiddlewareG < TestMiddleware; def call(e); @app.call(e); end; end
-  class TestMiddlewareH < TestMiddleware; def call(e); @app.call(e); end; end
-  class TestMiddlewareI < TestMiddleware; def call(e); @app.call(e); end; end
-  class TestMiddlewareJ < TestMiddleware; def call(e); @app.call(e); end; end
-  class TestAppWithParams
-    def call(env)
-      params = {
-        'user' => {
-          'shipping_address' => {
-            'street' => '1234 Nowhere Road',
-            'city'   => 'Nowhere',
-            'state'  => 'TX'
-          },
-          'billing_address' => {
-            'street' => '4321 Nowhere Lane',
-            'city'   => 'Nowhere',
-            'state'  => 'TX'
-          }
-        }
-      }
-      perform_action_with_newrelic_trace(:name => 'dorkbot', :params => params) do
-        [200, { 'Content-Type' => 'text/html' }, ['<body>hi</body>']]
-      end
-    end
-  end
-  class TestApp
-    def call(env)
-      [200, { 'Content-Type' => 'text/html' }, ['<body>hi</body>']]
-    end
-  end
-  def setup
-    require 'new_relic/rack/browser_monitoring'
-    @config = {
-      :beacon          => 'beacon',
-      :browser_key     => 'browserKey',
-      :js_agent_loader => 'loader',
-      :encoding_key    => 'lolz',
-      :application_id  => '5, 6', # collector can return app multiple ids
-      :'rum.enabled'   => true,
-      :license_key     => 'a' * 40
-    }
-    NewRelic::Agent.config.add_config_for_testing(@config)
-    NewRelic::Agent.manual_start(
-      :monitor_mode   => false
-    )
-    NewRelic::Agent.agent.events.notify(:finished_configuring)
-    middlewares = [
-      TestMiddlewareA,
-      TestMiddlewareB,
-      TestMiddlewareC,
-      TestMiddlewareD,
-      TestMiddlewareE,
-      TestMiddlewareF,
-      TestMiddlewareG,
-      TestMiddlewareH,
-      TestMiddlewareI,
-      TestMiddlewareJ,
-      NewRelic::Rack::BrowserMonitoring
-    ]
-    TestAppWithParams.class_eval do
-      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-    end
-    @stack = Rack::Builder.new do
-      middlewares.each { |m| use m }
-      run TestApp.new
-    end.to_app
-    @stack_with_params = Rack::Builder.new do
-      middlewares.each { |m| use m }
-      run TestAppWithParams.new
-    end.to_app
-    @env = {
-      'SCRIPT_NAME'  => '',
-      'PATH_INFO'    => '/users/12/blogs',
-      'QUERY_STRING' => 'q=foobar'
-    }
-  end
-  def test_basic_middleware_stack()
-    measure do
-      @stack.call(@env.dup)
-    end
-  end
-  def test_request_with_params_capture_params_off
-    measure do
-      @stack_with_params.call(@env.dup)
-    end
-  end
-  def test_request_with_params_capture_params_on
-    NewRelic::Agent.config.add_config_for_testing(:capture_params => true)
-    NewRelic::Agent.agent.events.notify(:finished_configuring)
-    measure do
-      @stack_with_params.call(@env.dup)
-    end
-  end
-end

data/test/performance/suites/redis.rb DELETED Viewed

@@ -1,45 +0,0 @@
-# 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.
-# Primarily just tests allocations around argument formatting
-class Redis < Performance::TestCase
-  def test_no_args
-    with_config(:'transaction_tracer.record_redis_arguments' => true) do
-      command = ["lonely_command"]
-      measure do
-        NewRelic::Agent::Datastores::Redis.format_command(command)
-      end
-    end
-  end
-  def test_args
-    with_config(:'transaction_tracer.record_redis_arguments' => true) do
-      commands = ["argumentative", "commands", "get", "called", "a", "bunch"]
-      measure do
-        NewRelic::Agent::Datastores::Redis.format_command(commands)
-      end
-    end
-  end
-  def test_long_args
-    with_config(:'transaction_tracer.record_redis_arguments' => true) do
-      commands = ["loooooong_command", "a" * 100, "b" * 100, "c" * 100]
-      measure do
-        NewRelic::Agent::Datastores::Redis.format_command(commands)
-      end
-    end
-  end
-  def test_pipelined
-    with_config(:'transaction_tracer.record_redis_arguments' => true) do
-      pipeline = [
-        ["first", "a" * 100, "b" * 100, "c" * 100],
-        ["second", "a" * 100, "b" * 100, "c" * 100]]
-      measure do
-        NewRelic::Agent::Datastores::Redis.format_pipeline_commands(pipeline)
-      end
-    end
-  end
-end

data/test/performance/suites/rules_engine.rb DELETED Viewed

@@ -1,35 +0,0 @@
-# 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.
-class RulesEngineTests < Performance::TestCase
-  def setup
-    @basic_rule_specs = {
-      "transaction_segment_terms": [
-        {
-          "prefix": "WebTransaction/Custom",
-          "terms": ["one", "two", "three"]
-        },
-        {
-          "prefix": "WebTransaction/Uri",
-          "terms": ["seven", "eight", "nine"]
-        }
-      ]
-    }
-  end
-  def test_rules_engine_init_transaction_rules
-    measure do
-      NewRelic::Agent::RulesEngine.create_transaction_rules(@basic_rule_specs)
-    end
-  end
-  def test_rules_engine_rename_transaction_rules
-    measure do
-      rules_engine = NewRelic::Agent::RulesEngine.create_transaction_rules(@basic_rule_specs)
-      rules_engine.rename "WebTransaction/Uri/one/two/seven/user/nine/account"
-      rules_engine.rename "WebTransaction/Custom/one/two/seven/user/nine/account"
-      rules_engine.rename "WebTransaction/Other/one/two/foo/bar"
-    end
-  end
-end

data/test/performance/suites/rum_autoinsertion.rb DELETED Viewed

@@ -1,75 +0,0 @@
-# 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.
-class RumAutoInsertion < Performance::TestCase
-  attr_reader :browser_monitor, :html, :html_with_meta, :html_with_meta_after
-  def setup
-    # Don't require until we're actually running tests to avoid weirdness in
-    # the parent runner process...
-    require 'new_relic/agent'
-    require 'new_relic/rack/browser_monitoring'
-    NewRelic::Agent.manual_start
-    @config = {
-      :beacon                 => 'beacon',
-      :browser_key            => 'browserKey',
-      :application_id         => '5, 6', # collector can return app multiple ids
-      :'rum.enabled'          => true,
-      :license_key            => 'a' * 40,
-      :js_agent_loader        => 'loader'
-    }
-    NewRelic::Agent.config.add_config_for_testing(@config)
-    @app = Class.new do
-      attr_accessor :text
-      def call(*_)
-        [200, { "Content-Type" => "text/html" }, [text]]
-      end
-    end.new
-    @browser_monitor = NewRelic::Rack::BrowserMonitoring.new(@app)
-    @html = "<html><head>#{'<script>alert("boo");</script>' * 1_000}</head><body></body></html>"
-    @html_with_meta = "<html><head><meta http-equiv='X-UA-Compatible' content='IE=7'/>#{'<script>alert("boo");</script>' * 1_000}</head><body></body></html>"
-    @html_with_meta_after = "<html><head>#{'<script>alert("boo");</script>' * 1_000}<meta http-equiv='X-UA-Compatible' content='IE=7'/></head><body></body></html>"
-    host_class = Class.new do
-      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
-      def run
-        yield
-      end
-      add_transaction_tracer :run
-    end
-    @host = host_class.new
-  end
-  def teardown
-    NewRelic::Agent.shutdown
-  end
-  def test_rum_autoinsertion
-    run_autoinstrument_source(html)
-  end
-  def test_rum_autoinsertion_with_x_ua_compatible
-    run_autoinstrument_source(html_with_meta)
-  end
-  def test_rum_autoinsertion_with_x_ua_compatible_after
-    run_autoinstrument_source(html_with_meta_after)
-  end
-  def run_autoinstrument_source(text)
-    @app.text = text
-    @host.run do
-      measure do
-        browser_monitor.call({})
-      end
-    end
-  end
-end

data/test/performance/suites/segment_terms_rule.rb DELETED Viewed

@@ -1,27 +0,0 @@
-# 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.
-class SegmentTermsRuleTests < Performance::TestCase
-  def setup
-  end
-  def test_segment_terms_rule_matches?
-    measure do
-      NewRelic::Agent::RulesEngine::SegmentTermsRule.new({
-        'prefix' => 'foo/bar/',
-        'terms'  => []
-      }).matches?('foo/bar')
-    end
-  end
-  def test_segment_terms_rule_apply
-    measure do
-      NewRelic::Agent::RulesEngine::SegmentTermsRule.new({
-        'prefix' => 'foo/bar/',
-        'terms'  => []
-      }).apply('foo/bar/baz/qux')
-    end
-  end
-end

data/test/performance/suites/sql_obfuscation.rb DELETED Viewed

@@ -1,50 +0,0 @@
-# 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.
-class SqlObfuscationTests < Performance::TestCase
-  def setup
-    require 'new_relic/agent/database'
-    long_query = "SELECT DISTINCT table0.* FROM `table0` INNER JOIN `table1` ON `table1`.`metric_id` = `table0`.`id` LEFT JOIN `table3` ON table3.id_column = table0.id_column AND table3.metric_id = table0.id WHERE `table1`.`other_id` IN (92776, 49992, 61710, 84911, 90744, 40647) AND `table0`.`id_column` = 81067 AND `table0`.`col12` = '' AND ((table0.id_column=81067 )) AND ((table3.timestamp IS NULL OR table3.timestamp > 1406810459)) AND (((table0.name LIKE 'WebTransaction/%') OR ((table0.name LIKE 'OtherTransaction/%/%') AND (table0.name NOT LIKE '%/all')))) LIMIT 2250"
-    short_query = "SELECT * FROM `table` WHERE id=2540250 AND name LIKE 'OtherTransaction/%/%'"
-    @long_query  = NewRelic::Agent::Database::Statement.new(long_query)
-    @short_query = NewRelic::Agent::Database::Statement.new(short_query)
-    @long_query_pg = NewRelic::Agent::Database::Statement.new(long_query, {:adapter => 'postgresql'})
-    @short_query_pg = NewRelic::Agent::Database::Statement.new(short_query, {:adapter => 'postgresql'})
-  end
-  def test_obfuscate_sql
-    measure do
-      NewRelic::Agent::Database.obfuscate_sql(@long_query)
-      NewRelic::Agent::Database.obfuscate_sql(@short_query)
-    end
-  end
-  def test_obfuscate_sql_postgres
-    measure do
-      NewRelic::Agent::Database.obfuscate_sql(@long_query_pg)
-      NewRelic::Agent::Database.obfuscate_sql(@short_query_pg)
-    end
-  end
-  def test_obfuscate_cross_agent_tests
-    test_cases = load_cross_agent_test('sql_obfuscation/sql_obfuscation')
-    statements = []
-    test_cases.each do |test_case|
-      query = test_case['sql']
-      test_case['dialects'].map do |dialect|
-        statements << NewRelic::Agent::Database::Statement.new(query, {:adapter => dialect})
-      end
-    end
-    measure do
-      statements.each do |statement|
-        NewRelic::Agent::Database.obfuscate_sql(statement)
-      end
-    end
-  end
-end

data/test/performance/suites/startup.rb DELETED Viewed

@@ -1,12 +0,0 @@
-# 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.
-class StartupShutdown < Performance::TestCase
-  def test_startup_shutdown
-    measure do
-      NewRelic::Agent.manual_start
-      NewRelic::Agent.shutdown
-    end
-  end
-end

data/test/performance/suites/stats_hash.rb DELETED Viewed

@@ -1,31 +0,0 @@
-# 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.
-class StatsHashPerfTest < Performance::TestCase
-  def setup
-    @hash = NewRelic::Agent::StatsHash.new
-    @specs = (1..100).map { |i| NewRelic::MetricSpec.new("foo#{i}") }
-  end
-  def test_record
-    measure do
-      hash = NewRelic::Agent::StatsHash.new
-      @specs.each do |spec|
-        hash.record(spec, 1)
-      end
-    end
-  end
-  def test_merge
-    measure do
-      incoming = NewRelic::Agent::StatsHash.new
-      @specs.each do |i|
-        incoming.record(NewRelic::MetricSpec.new("foo#{i}"), 1)
-      end
-      hash = NewRelic::Agent::StatsHash.new
-      hash.merge!(incoming)
-    end
-  end
-end

data/test/performance/suites/thread_profiling.rb DELETED Viewed

@@ -1,116 +0,0 @@
-# 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.
-class ThreadProfiling < Performance::TestCase
-  def recurse(n, final)
-    if n == 0
-      final.call
-    else
-      recurse(n-1, final)
-    end
-  end
-  def block
-    @mutex.synchronize do
-      @cvar.wait(@mutex)
-    end
-  end
-  def setup
-    require 'new_relic/agent/threading/backtrace_service'
-    @nthreads = 16
-    @mutex = Mutex.new
-    @cvar = ConditionVariable.new
-    @threadq = Queue.new
-    @threads = []
-    @nthreads.times do
-      @threads << Thread.new do
-        @threadq << self
-        transaction_state = NewRelic::Agent::TransactionState.tl_get
-        def transaction_state.in_web_transaction?; true; end
-        recurse(50, method(:block))
-      end
-    end
-    # Ensure that all threads have had a chance to start up
-    started_count = 0
-    while started_count < @nthreads do
-      @threadq.pop
-      started_count += 1
-    end
-    @service = NewRelic::Agent::Threading::BacktraceService.new
-    @worker_loop = @service.worker_loop
-    def @worker_loop.run; end # we want to drive it manually
-  end
-  def teardown
-    @cvar.broadcast
-    @threads.each(&:join)
-  rescue Exception => e
-    if e.message =~ /Deadlock/
-      Thread.list.select(&:alive?).each do |t|
-        STDERR.puts "*" * 80
-        STDERR.puts "Live thread: #{t.inspect}"
-        STDERR.puts "Backtrace:"
-        STDERR.puts (t.backtrace || []).join("\n")
-        STDERR.puts "*" * 80
-      end
-    end
-    raise e
-  end
-  def test_gather_backtraces
-    @service.subscribe(NewRelic::Agent::Threading::BacktraceService::ALL_TRANSACTIONS)
-    measure do
-      @service.poll
-    end
-    @service.unsubscribe(NewRelic::Agent::Threading::BacktraceService::ALL_TRANSACTIONS)
-  end
-  def test_gather_backtraces_subscribed
-    @service.subscribe('eagle')
-    measure do
-      t0 = Time.now.to_f
-      @service.poll
-      payload = {
-        :name => 'eagle',
-        :bucket => :request,
-        :start_timestamp => t0,
-        :duration => Time.now.to_f-t0,
-        :thread => @threads.sample
-      }
-      @service.on_transaction_finished(payload)
-    end
-    @service.unsubscribe('eagle')
-  end
-  def test_generating_traces
-    require 'new_relic/agent/threading/thread_profile'
-    measure do
-      profile = ::NewRelic::Agent::Threading::ThreadProfile.new({})
-      aggregate_lots_of_nodes(profile, 5, [])
-      profile.generate_traces
-    end
-  end
-  def aggregate_lots_of_nodes(profile, depth, trace)
-    if depth > 0
-      7.times do |i|
-        trace.push("path#{i}:#{i+50}:in `depth#{depth}'")
-        aggregate_lots_of_nodes(profile, depth-1, trace)
-        trace.pop
-      end
-    else
-      profile.aggregate(trace, :request, Thread.current)
-    end
-  end
-end