newrelic_rpm 4.1.0.333 → 4.2.0.334

data/test/performance/suites/active_record.rb

@@ -1,26 +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 'new_relic/agent/instrumentation/active_record_helper'
-
-class ActiveRecordTest < Performance::TestCase
-
-  NAME    = "Model Load"
-  SQL     = "SELECT * FROM star"
-  ADAPTER = "mysql2"
-
-  def test_helper_by_name
-    measure do
-      NewRelic::Agent::Instrumentation::ActiveRecordHelper.product_operation_collection_for NAME, SQL, ADAPTER
-    end
-  end
-
-  UNKNOWN_NAME = "Blah"
-
-  def test_helper_by_sql
-    measure do
-      NewRelic::Agent::Instrumentation::ActiveRecordHelper.product_operation_collection_for UNKNOWN_NAME, SQL, ADAPTER
-    end
-  end
-end

data/test/performance/suites/active_record_subscriber.rb

@@ -1,100 +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 'new_relic/agent/instrumentation/active_record_subscriber'
-
-# Note: This test was cobbled together from the AR Subscriber Unit Test and
-# by cut & paste of ActiveSupport::Notifcations::Event from Rails source.
-# This test is here because it's useful, not because it's well written.
-# If you have a desire to improve this test, do it!
-
-unless defined?(ActiveSupport::Notifications::Event)
-  module ActiveSupport
-    module Notifications
-      class Event
-        attr_reader :name, :time, :transaction_id, :payload, :children
-        attr_accessor :end
-
-        def initialize(name, start, ending, transaction_id, payload)
-          @name           = name
-          @payload        = payload.dup
-          @time           = start
-          @transaction_id = transaction_id
-          @end            = ending
-          @children       = []
-          @duration       = nil
-        end
-
-        # Returns the difference in milliseconds between when the execution of the
-        # event started and when it ended.
-        #
-        #   ActiveSupport::Notifications.subscribe('wait') do |*args|
-        #     @event = ActiveSupport::Notifications::Event.new(*args)
-        #   end
-        #
-        #   ActiveSupport::Notifications.instrument('wait') do
-        #     sleep 1
-        #   end
-        #
-        #   @event.duration # => 1000.138
-        def duration
-          @duration ||= 1000.0 * (self.end - time)
-        end
-
-        def <<(event)
-          @children << event
-        end
-
-        def parent_of?(event)
-          @children.include? event
-        end
-      end
-    end
-  end
-end
-
-class ActiveRecordSubscriberTest < Performance::TestCase
-  def setup
-    @config = { :adapter => 'mysql', :host => 'server' }
-    @connection = Object.new
-    @connection.instance_variable_set(:@config, @config)
-
-
-    @params = {
-      :name => 'NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order Load',
-      :sql => 'SELECT * FROM sandwiches',
-      :connection_id => @connection.object_id
-    }
-
-    @subscriber = NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.new
-    if @subscriber.respond_to? :active_record_config_for_event
-      @subscriber.class.send(:remove_method, :active_record_config_for_event)
-      @subscriber.class.send(:define_method, :active_record_config_for_event) do |args|
-        @config
-      end
-    else
-      @subscriber.class.send(:remove_method, :active_record_config)
-      @subscriber.class.send(:define_method, :active_record_config) do |args|
-        @config
-      end
-    end
-  end
-
-
-  def test_subscriber_in_txn
-    measure do
-      in_transaction do
-        simulate_query
-      end
-    end
-  end
-
-  EVENT_NAME = 'sql.active_record'.freeze
-
-  def simulate_query(duration=nil)
-    @subscriber.start(EVENT_NAME, :id, @params)
-    advance_time(duration) if duration
-    @subscriber.finish(EVENT_NAME, :id, @params)
-  end
-end

data/test/performance/suites/agent_attributes.rb

@@ -1,62 +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 'securerandom'
-
-class AgentAttributesTests < Performance::TestCase
-  def setup
-    require 'new_relic/agent/attribute_filter'
-  end
-
-  ALPHA = "alpha".freeze
-  BETA  = "beta".freeze
-
-  def test_empty_agent_attributes
-    @filter = NewRelic::Agent::AttributeFilter.new(NewRelic::Agent.config)
-
-    measure do
-      @filter.apply(ALPHA, NewRelic::Agent::AttributeFilter::DST_ALL)
-      @filter.apply(BETA, NewRelic::Agent::AttributeFilter::DST_ALL)
-    end
-  end
-
-  def test_with_attribute_rules
-    with_config(:'attributes.include' => ['alpha'],
-                :'attributes.exclude' => ['beta']) do
-
-      @filter = NewRelic::Agent::AttributeFilter.new(NewRelic::Agent.config)
-
-      measure do
-        @filter.apply(ALPHA, NewRelic::Agent::AttributeFilter::DST_ALL)
-        @filter.apply(BETA, NewRelic::Agent::AttributeFilter::DST_ALL)
-      end
-    end
-  end
-
-  def test_with_wildcards
-    with_config(:'attributes.include' => ['alpha*'],
-                :'attributes.exclude' => ['beta*']) do
-
-      @filter = NewRelic::Agent::AttributeFilter.new(NewRelic::Agent.config)
-
-      measure do
-        @filter.apply(ALPHA, NewRelic::Agent::AttributeFilter::DST_ALL)
-        @filter.apply(BETA, NewRelic::Agent::AttributeFilter::DST_ALL)
-      end
-    end
-  end
-
-  def test_with_tons_o_rules
-    with_config(:'attributes.include' => 100.times.map { SecureRandom.hex },
-                :'attributes.exclude' => 100.times.map { SecureRandom.hex }) do
-
-      @filter = NewRelic::Agent::AttributeFilter.new(NewRelic::Agent.config)
-
-      measure do
-        @filter.apply(ALPHA, NewRelic::Agent::AttributeFilter::DST_ALL)
-        @filter.apply(BETA, NewRelic::Agent::AttributeFilter::DST_ALL)
-      end
-    end
-  end
-end

data/test/performance/suites/config.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 ConfigPerfTests < Performance::TestCase
-  def setup
-    @config = NewRelic::Agent::Configuration::Manager.new
-    @config.add_config_for_testing(:my_value => "boo")
-  end
-
-  def test_raw_access
-    measure do
-      v = @config[:my_value]
-    end
-  end
-
-  def test_defaulting_access
-    measure do
-      v = @config[:log_level]
-    end
-  end
-
-  def test_missing_key
-    measure do
-      v = @config[:nope]
-    end
-  end
-
-  def test_blowing_cache
-    measure do
-      @config.reset_cache
-      v = @config[:my_value]
-    end
-  end
-end

data/test/performance/suites/datastores.rb

@@ -1,59 +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 DatastoresPerfTest < Performance::TestCase
-  class FauxDB
-    def self.query
-      "foo"
-    end
-  end
-
-  def test_instrumentation_via_trace
-    db_class = Class.new do
-      def query
-        "foo"
-      end
-    end
-
-    NewRelic::Agent::Datastores.trace(db_class, "query", "FakeDB")
-    db = db_class.new
-
-    measure do
-      in_transaction do
-        db.query
-      end
-    end
-  end
-
-  def test_wrap
-    product = "FauxDB".freeze
-    operation = "query".freeze
-    collection = "collection".freeze
-
-    measure do
-      in_transaction do
-        NewRelic::Agent::Datastores.wrap product, operation, collection do
-          FauxDB.query
-        end
-      end
-    end
-  end
-
-  SQL = "select * from users".freeze
-  METRIC_NAME = "Datastore/statement/MySQL/users/select".freeze
-
-  def test_notice_sql
-    measure do
-      NewRelic::Agent::Datastores.notice_sql(SQL, METRIC_NAME, 3.0)
-    end
-  end
-
-  def test_segment_notice_sql
-    segment = NewRelic::Agent::Transaction::DatastoreSegment.new "MySQL", "select", "users"
-    conf = {:adapter => :mysql}
-    measure do
-      segment._notice_sql SQL, conf
-    end
-  end
-end

data/test/performance/suites/error_collector.rb

@@ -1,28 +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 ErrorCollectorTests < Performance::TestCase
-  def setup
-    @txn_name = "Controller/blogs/index".freeze
-    @err_msg = "Sorry!".freeze
-  end
-
-  def test_notice_error
-    measure do
-      in_transaction :name => @txn_name do
-        NewRelic::Agent.notice_error StandardError.new @err_msg
-      end
-    end
-  end
-
-  def test_notice_error_with_custom_attributes
-    opts = {:custom_params => {:name => "Wes Mantooth", :channel => 9}}
-
-    measure do
-      in_transaction :name => @txn_name do
-        NewRelic::Agent.notice_error StandardError.new(@err_msg), opts
-      end
-    end
-  end
-end

data/test/performance/suites/external_segment.rb

@@ -1,80 +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 'net/http'
-require 'new_relic/agent/obfuscator'
-
-class ExternalSegment < Performance::TestCase
-
-  CONFIG = {
-      :license_key     => 'a' * 40,
-      :'cross_application_tracer.enabled' => true,
-      :cross_process_id                   => "1#1884",
-      :encoding_key                       => "jotorotoes",
-      :trusted_account_ids                => [1]
-  }
-
-  def setup
-    NewRelic::Agent.config.add_config_for_testing(CONFIG)
-
-    NewRelic::Agent.manual_start(
-      :monitor_mode   => false
-    )
-  end
-
-  TEST_URI = URI("http://localhost:3035/status")
-
-  def test_external_request
-    io_server = start_server
-    measure do
-      in_transaction do
-        Net::HTTP.get(TEST_URI)
-      end
-    end
-    stop_server io_server
-  end
-
-  def test_external_cat_request
-    io_server = start_server
-    reply_with_cat_headers io_server
-    measure do
-      in_transaction do
-        Net::HTTP.get(TEST_URI)
-      end
-    end
-    stop_server io_server
-  end
-
-  SERVER_SCRIPT_PATH = File.expand_path('../../../script/external_server.rb', __FILE__)
-
-  def start_server
-    io = IO.popen(SERVER_SCRIPT_PATH, 'r+')
-    response = JSON.parse(io.gets)
-    if response["message"] == "started"
-      io
-    else
-      fail "Could not start server"
-    end
-  end
-
-  def reply_with_cat_headers io_server
-    message = {
-      :command => "add_headers",
-      :payload => cat_response_headers
-    }.to_json
-    io_server.puts message
-  end
-
-  def stop_server io_server
-    message = {:command => "shutdown"}.to_json
-    io_server.puts message
-    Process.wait
-  end
-
-  def cat_response_headers
-    obfuscator = NewRelic::Agent::Obfuscator.new NewRelic::Agent.config[:encoding_key]
-    app_data = obfuscator.obfuscate(["1#1884", "txn-name", 2, 8, 0, 'BEC1BC64675138B9'].to_json) + "\n"
-    {'X-NewRelic-App-Data' => app_data}
-  end
-end

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