newrelic_rpm 4.0.0.332 → 4.4.0.336

data/test/performance/suites/marshalling.rb

@@ -1,148 +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 File.join(File.dirname(__FILE__), '..', '..', 'agent_helper')
-
-class Marshalling < Performance::TestCase
-  def setup
-    @payload = build_analytics_events_payload
-    @tt_payload = build_transaction_trace_payload
-  end
-
-  def test_basic_marshalling_json
-    with_config(:normalize_json_string_encodings => true) do
-      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-      measure do
-        marshaller.dump(@payload)
-        marshaller.dump(@tt_payload)
-      end
-    end
-  end
-
-  def test_json_marshalling_binary_strings
-    with_config(:normalize_json_string_encodings => true) do
-      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-      convert_strings_to_binary(@payload)
-      convert_strings_to_binary(@tt_payload)
-      measure do
-        marshaller.dump(@payload)
-        marshaller.dump(@tt_payload)
-      end
-    end
-  end
-
-  def test_json_marshalling_utf16_strings
-    with_config(:normalize_json_string_encodings => true) do
-      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-      convert_strings_to_utf16(@payload)
-      convert_strings_to_utf16(@tt_payload)
-      measure do
-        marshaller.dump(@payload)
-        marshaller.dump(@tt_payload)
-      end
-    end
-  end
-
-  def test_json_marshalling_latin1_strings
-    with_config(:normalize_json_string_encodings => true) do
-      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-      convert_strings_to_latin1(@payload)
-      convert_strings_to_latin1(@tt_payload)
-      measure do
-        marshaller.dump(@payload)
-        marshaller.dump(@tt_payload)
-      end
-    end
-  end
-
-  # Skips Strings used as Hash keys, since they are frozen
-  def each_string(object, &blk)
-    case object
-    when String
-      blk.call(object)
-    when Array
-      object.map! { |x| each_string(x, &blk) }
-    when Hash
-      object.values.each do |v|
-        each_string(v, &blk)
-      end
-    end
-  end
-
-  BYTE_ALPHABET = (0..255).to_a.freeze
-
-  def generate_random_string(length)
-    bytes = []
-    meth = BYTE_ALPHABET.respond_to?(:sample) ? :sample : :choice
-    length.times { bytes << BYTE_ALPHABET.send(meth) }
-    bytes.pack("C*")
-  end
-
-  def convert_strings_to_binary(object)
-    each_string(object) do |s|
-      s.replace(generate_random_string(s.bytesize))
-    end
-  end
-
-  def convert_strings_to_utf16(object)
-    each_string(object) do |s|
-      if s.respond_to?(:encode!)
-        s.encode!('UTF-16')
-      else
-        require 'iconv'
-        s.replace(Iconv.conv('UTF-16', 'UTF-8', s))
-      end
-    end
-  end
-
-  def convert_strings_to_latin1(object)
-    return object unless "".respond_to?(:force_encoding)
-
-    each_string(object) do |s|
-      s.replace(generate_random_string(s.bytesize)).force_encoding('ISO-8859-1')
-    end
-  end
-
-  # Build an object graph that approximates a transaction trace in structure
-  def build_transaction_trace_payload(depth=6)
-    root = []
-    fanout = depth
-    fanout.times do |i|
-      node = [
-        i * rand(10),
-        i * rand(10),
-        "This/Is/The/Name/Of/A/Transaction/Trace/Node/Depth/#{depth}/#{i}",
-        {
-          "sql" => "SELECT #{(0..100).to_a.join(",")}"
-        },
-        []
-      ]
-      node[-1] = build_transaction_trace_payload(depth-1) if depth > 0
-      root << node
-    end
-    root
-  end
-
-  # Build an object graph that approximates a large analytics_event_data payload
-  def build_analytics_events_payload
-    events = []
-    1000.times do
-      event = {
-        'timestamp'        => Time.now.to_f,
-        'name'             => "Controller/foo/bar",
-        'type'             => "Transaction",
-        'duration'         => rand,
-        'databaseDuration' => rand,
-        'databaseCallCount'=> rand,
-        'gcCumulative'     => rand,
-        'host'             => 'lo-calhost',
-        'color'            => 'blue-green',
-        'shape'            => 'squarish',
-        'texture'          => 'sort of lumpy like a bag of frozen peas'
-      }
-      events << [event, {}]
-    end
-    [rand(1000000), events]
-  end
-end

data/test/performance/suites/queue_time.rb

@@ -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

@@ -1,136 +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,
-      :developer_mode  => false
-    }
-    NewRelic::Agent.config.add_config_for_testing(@config)
-
-    NewRelic::Agent.manual_start(
-      :developer_mode => false,
-      :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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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