newrelic_rpm 3.12.0.288 → 9.10.2

data/test/multiverse/suites/mongo/helpers/mongo_server.rb

@@ -1,241 +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 'fileutils'
-require 'timeout'
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'helpers', 'file_searching'))
-
-class MongoServer
-  extend NewRelic::TestHelpers::FileSearching
-
-  attr_reader :type
-  attr_accessor :port, :client
-
-  def initialize(type = :single)
-    @type = type
-    lock_port
-
-    make_directories
-  end
-
-  def self.count(type = :all)
-    count = `ps aux | grep mongo[d]`.split("\n").length
-    count -= Dir.glob(File.join(MongoServer.pid_directory, '*.pid')).length if type == :children
-    count
-  end
-
-  def self.tmp_directory
-    ENV["MULTIVERSE_TMP"] || File.join(gem_root, 'tmp')
-  end
-
-  def self.port_lock_directory
-    File.join(tmp_directory, 'ports')
-  end
-
-  def self.pid_directory
-    File.join(tmp_directory, 'pids')
-  end
-
-  def self.db_directory
-    File.join(tmp_directory, 'db')
-  end
-
-  def self.log_directory
-    File.join(tmp_directory, 'log')
-  end
-
-  def ping
-    return unless self.client
-    self.client['admin'].command( { 'ping' => 1 } )
-  end
-
-  def pingable?
-    ping == { "ok" => 1.0 }
-  end
-
-  def make_directories
-    directories = [
-      MongoServer.pid_directory,
-      MongoServer.db_directory,
-      MongoServer.log_directory,
-      db_path
-    ]
-
-    FileUtils.mkdir_p(directories)
-  end
-
-  def make_port_lock_directory
-    FileUtils.mkdir_p(MongoServer.port_lock_directory)
-  end
-
-  def port_lock_path
-    File.join(MongoServer.port_lock_directory, "#{self.port}.lock")
-  end
-
-  def pid_path
-    File.join(MongoServer.pid_directory, "#{self.port}-#{self.object_id}-#{Process.pid}.pid")
-  end
-
-  def db_path
-    File.join(MongoServer.db_directory, "data_#{self.port}")
-  end
-
-  def log_path
-    File.join(MongoServer.log_directory, "#{self.port}.log")
-  end
-
-  def start(wait_for_startup = true)
-    lock_port
-
-    unless running?
-      `#{startup_command}`
-
-      wait_until do
-        running?
-      end
-
-      if wait_for_startup
-        create_client
-        wait_until do
-          pingable?
-        end
-      end
-    end
-
-    self
-  end
-
-  def wait_until(seconds = 10)
-    Timeout.timeout(seconds) do
-      sleep 0.1 until yield
-    end
-  end
-
-  def startup_command
-    pid_file = "--pidfilepath #{pid_path}"
-    log_file = "--logpath #{log_path} "
-    fork     = "--fork"
-
-    dbpath = "--dbpath #{db_path}"
-    port_flag = "--port #{self.port}"
-    small_mongo = "--oplogSize 128 --smallfiles"
-    repl_set = "--replSet multiverse"
-
-    base = "#{port_flag} #{fork} #{pid_file} #{log_file} #{small_mongo} #{dbpath}"
-
-    mongod_path = ENV['MONGOD_PATH'] || 'mongod'
-    if self.type == :single
-      "#{mongod_path} #{base}"
-    elsif self.type == :replica
-      "#{mongod_path} #{repl_set} #{base}"
-    end
-  end
-
-  def create_client(client_class = nil)
-    require 'mongo'
-    if defined? MongoClient
-      client_class ||= MongoClient
-    else
-      client_class ||= Mongo::Connection
-    end
-
-    begin
-      self.client = client_class.new('localhost', self.port, :connect_timeout => 10)
-    rescue Mongo::ConnectionFailure => e
-      raise e unless message == "Failed to connect to a master node at localhost:#{port}"
-      retry
-    end
-  end
-
-  def stop
-    if pid
-      begin
-        Process.kill('TERM', pid)
-      rescue Errno::ESRCH
-        # fine if we're already gone...
-      end
-
-      wait_until do
-        !running?
-      end
-
-      cleanup_files
-      self.client = nil
-    end
-
-    release_port
-    self
-  end
-
-  def running?
-    return false unless pid
-    Process.kill(0, pid) == 1
-  rescue Errno::ESRCH
-    false
-  end
-
-  def pid
-    File.read(pid_path).to_i if File.exists? pid_path
-  end
-
-  def next_available_port
-    used_ports = all_port_lock_files.map do |filename|
-      File.basename(filename, '.lock').to_i
-    end
-
-    if used_ports.empty?
-      27017
-    else
-      used_ports.sort.last + 1
-    end
-  end
-
-  def all_port_lock_files
-    Dir.glob(File.join(MongoServer.port_lock_directory, '*.lock'))
-  end
-
-  def lock_port
-    return if self.port
-
-    make_port_lock_directory
-
-    retry_on_exception(:exception => Errno::EEXIST, :tries => 10) do
-      self.port = next_available_port
-      File.new(port_lock_path, File::CREAT|File::EXCL)
-    end
-  end
-
-  def retry_on_exception(options)
-    exception = options.fetch(:exception, StandardError)
-    message = options[:message]
-    maximum_tries = options.fetch(:tries, 3)
-
-    tries = 0
-
-    begin
-      yield
-    rescue exception => e
-      if message
-        raise e unless e.message.include? message
-      end
-
-      sleep 0.1
-      tries += 1
-      retry unless tries > maximum_tries
-      raise e
-    end
-  end
-
-  def release_port
-    FileUtils.rm port_lock_path, :force => true
-    self.port = nil
-  end
-
-  # PID file needs to be cleaned up for our process checking logic
-  # DB needs to get cleaned up because it's massive
-  def cleanup_files
-    FileUtils.rm(pid_path)
-    FileUtils.rm_rf(db_path)
-  end
-end

data/test/multiverse/suites/mongo/helpers/mongo_server_test.rb

@@ -1,176 +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.expand_path(File.join(File.dirname(__FILE__), 'mongo_server'))
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'helpers', 'file_searching'))
-require 'test/unit'
-require 'mocha/setup'
-
-class MongoServerTest < Test::Unit::TestCase
-  include NewRelic::TestHelpers::FileSearching
-
-  def setup
-    @server = MongoServer.new
-  end
-
-  def teardown
-    @server.stop
-  end
-
-  def test_new_server_has_a_locked_port
-    assert File.exists?(@server.port_lock_path)
-  end
-
-  def test_creating_a_new_server_after_locking_port_uses_the_next_port
-    new_server = MongoServer.new
-    new_server_port = new_server.port
-    assert_equal @server.port + 1, new_server_port
-  ensure
-    new_server.stop
-  end
-
-  def test_pid_path_is_unique_for_two_servers
-    new_server = MongoServer.new
-    pid_path1 = @server.start.pid_path
-    pid_path2 = new_server.start.pid_path
-
-    refute_equal pid_path1, pid_path2
-  ensure
-    new_server.stop
-  end
-
-  def test_release_port_deletes_the_port_lock_file
-    path = @server.port_lock_path
-    assert File.exists?(path)
-    @server.release_port
-    refute File.exists?(path)
-  end
-
-  def test_all_port_lock_files_returns_all_file_names
-    File.write(@server.port_lock_path, @server.port)
-    result = @server.all_port_lock_files
-    assert_equal [@server.port_lock_path], result
-  end
-
-  def test_start_creates_a_mongod_process
-    @server.start
-    assert_equal 1, MongoServer.count
-  end
-
-  def test_starting_twice_only_creates_one_process
-    @server.start
-    @server.start
-    assert_equal 1, MongoServer.count
-  end
-
-  def test_server_is_running_after_start
-    @server.start
-    assert @server.running?
-  end
-
-  def test_stop_kills_a_mongod_process
-    @server.start
-    @server.stop
-    assert_equal 0, MongoServer.count
-  end
-
-  def test_stop_releases_port
-    @server.start
-    assert File.exists?(@server.port_lock_path)
-    @server.stop
-    refute File.exists?(@server.port_lock_path)
-  end
-
-  def test_stop_deletes_pid_file
-    @server.start
-    assert File.exists?(@server.pid_path)
-    @server.stop
-    refute File.exists?(@server.pid_path)
-  end
-
-  def test_pingable_returns_true_if_ping_is_ok
-    ok_status = { "ok" => 1.0 }
-    @server.stubs(:ping).returns ok_status
-    assert @server.pingable?
-  end
-
-  def test_server_start_times_out_if_it_isnt_pingable
-    @server.stubs(:pingable?).returns false
-
-    assert_raise Timeout::Error do
-      @server.start
-    end
-  end
-
-  def test_server_count_returns_the_number_of_mongo_processes
-    previous_server_count = `ps aux | grep mongo[d]`.split("\n").length
-    @server.start
-    assert_equal previous_server_count + 1, MongoServer.count
-  end
-
-  def test_server_count_children_returns_number_of_mongo_processes_started_by_mongo_server
-    test_pid_path = File.join(MongoServer.tmp_directory, 'test.pid')
-    `mongod --pidfilepath #{test_pid_path} &`
-    pid = File.read(test_pid_path).to_i
-    @server.start
-    result = MongoServer.count(:children)
-
-    assert_equal 1, result
-  ensure
-    Process.kill('TERM', pid)
-    FileUtils.rm(test_pid_path)
-  end
-
-  def test_replica_set_servers_include_fork_flag
-    replica = MongoServer.new(:replica)
-    assert_includes replica.startup_command, '--fork'
-    replica.stop
-  end
-
-  def test_replica_set_servers_include_repl_set
-    replica = MongoServer.new(:replica)
-    assert_includes replica.startup_command, '--replSet'
-    replica.stop
-  end
-
-  def test_starting_a_server_creates_a_client
-    @server.start
-    assert @server.client
-  end
-
-  def test_ping_returns_ok_for_started_server
-    @server.start
-    ok_status = { "ok" => 1.0 }
-    assert_equal ok_status, @server.ping
-  end
-
-  def test_stop_sets_client_to_nil
-    @server.start
-    @server.stop
-    assert_nil @server.client
-  end
-
-  def test_ping_returns_nil_for_stopped_server
-    @server.start
-    @server.stop
-    assert_nil @server.ping
-  end
-
-  def test_servers_in_different_threads_use_unique_ports
-    threads = []
-
-    20.times do
-      threads << Thread.new do
-        MongoServer.new
-      end
-    end
-
-    servers = threads.map(&:value)
-
-    assert_equal 20, servers.map(&:port).uniq.length
-  ensure
-    servers.each(&:stop)
-  end
-end
-

data/test/multiverse/suites/mongo/mongo_connection_test.rb

@@ -1,39 +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 'mongo'
-require 'newrelic_rpm'
-require 'new_relic/agent/datastores/mongo'
-require 'securerandom'
-
-if NewRelic::Agent::Datastores::Mongo.is_supported_version?
-  require File.join(File.dirname(__FILE__), '..', '..', '..', 'helpers', 'mongo_metric_builder')
-  require File.join(File.dirname(__FILE__), 'helpers', 'mongo_server')
-  require File.join(File.dirname(__FILE__), 'helpers', 'mongo_replica_set')
-  require File.join(File.dirname(__FILE__), 'helpers', 'mongo_operation_tests')
-
-  class NewRelic::Agent::Instrumentation::MongoConnectionTest
-    include Mongo
-    include ::NewRelic::TestHelpers::MongoMetricBuilder
-    include ::MongoOperationTests
-
-    def setup
-      @client = Mongo::Connection.new($mongo.host, $mongo.port)
-      @database_name = "multiverse"
-      @database = @client.db(@database_name)
-      @collection_name = "tribbles-#{SecureRandom.hex(16)}"
-      @collection = @database.collection(@collection_name)
-
-      @tribble = {'name' => 'soterios johnson'}
-
-      NewRelic::Agent::Transaction.stubs(:recording_web_transaction?).returns(true)
-      NewRelic::Agent.drop_buffered_data
-    end
-
-    def teardown
-      NewRelic::Agent.drop_buffered_data
-      @database.drop_collection(@collection_name)
-    end
-  end
-end

data/test/multiverse/suites/mongo/mongo_instrumentation_test.rb

@@ -1,39 +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 'mongo'
-require 'newrelic_rpm'
-require 'new_relic/agent/datastores/mongo'
-require 'securerandom'
-
-if NewRelic::Agent::Datastores::Mongo.is_supported_version?
-  require File.join(File.dirname(__FILE__), '..', '..', '..', 'helpers', 'mongo_metric_builder')
-  require File.join(File.dirname(__FILE__), 'helpers', 'mongo_server')
-  require File.join(File.dirname(__FILE__), 'helpers', 'mongo_replica_set')
-  require File.join(File.dirname(__FILE__), 'helpers', 'mongo_operation_tests')
-
-  class NewRelic::Agent::Instrumentation::MongoInstrumentationTest < Minitest::Test
-    include Mongo
-    include ::NewRelic::TestHelpers::MongoMetricBuilder
-    include ::MongoOperationTests
-
-    def setup
-      @client = Mongo::MongoClient.new($mongo.host, $mongo.port)
-      @database_name = "multiverse"
-      @database = @client.db(@database_name)
-      @collection_name = "tribbles-#{SecureRandom.hex(16)}"
-      @collection = @database.collection(@collection_name)
-
-      @tribble = {'name' => 'soterios johnson'}
-
-      NewRelic::Agent::Transaction.stubs(:recording_web_transaction?).returns(true)
-      NewRelic::Agent.drop_buffered_data
-    end
-
-    def teardown
-      NewRelic::Agent.drop_buffered_data
-      @database.drop_collection(@collection_name)
-    end
-  end
-end

data/test/multiverse/suites/mongo/mongo_unsupported_version_test.rb

@@ -1,72 +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 'mongo'
-require 'newrelic_rpm'
-require 'new_relic/agent/datastores/mongo'
-
-if !NewRelic::Agent::Datastores::Mongo.is_supported_version?
-  class NewRelic::Agent::Instrumentation::MongoInstrumentationTest < Minitest::Test
-    include Mongo
-
-    def setup
-      @database_name = "multiverse"
-      @collection_name = "tribbles-#{SecureRandom.hex(16)}"
-      @tribble = {'name' => 'soterios johnson'}
-
-      setup_collection
-
-      NewRelic::Agent.drop_buffered_data
-    end
-
-    def teardown
-      NewRelic::Agent.drop_buffered_data
-      drop_collection
-    end
-
-    def test_records_metrics_for_insert
-      insert_to_collection
-      assert_metrics_not_recorded(["Datastore/all", "Datastore/allWeb", "Datastore/allOther"])
-    end
-
-    # API changes between 1.x and 2.x that we need to work around to make
-    # sure that we're testing unsupported versions properly
-    module Mongo1xUnsupported
-      def setup_collection
-        client = Mongo::Connection.new($mongo.host, $mongo.port)
-        @database = client.db(@database_name)
-        @collection = @database.collection(@collection_name)
-      end
-
-      def drop_collection
-        @database.drop_collection(@collection_name)
-      end
-
-      def insert_to_collection
-        @collection.insert(@tribble)
-      end
-    end
-
-    module Mongo2xUnsupported
-      def setup_collection
-        client = Mongo::Client.new(["#{$mongo.host}:#{$mongo.port}"], :database => @database_name, :connect => :direct)
-        @collection = client[@collection_name]
-      end
-
-      def drop_collection
-        @collection.drop
-      end
-
-      def insert_to_collection
-        @collection.insert_one(@tribble)
-      end
-    end
-
-    if NewRelic::Agent::Datastores::Mongo.is_version2?
-      include Mongo2xUnsupported
-    else
-      include Mongo1xUnsupported
-    end
-  end
-end

data/test/multiverse/suites/net_http/Envfile

@@ -1,4 +0,0 @@
-gemfile <<-RB
-  gem 'rack'
-  gem 'json', :platforms => [:rbx, :mri_18]
-RB

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

@@ -1,18 +0,0 @@
----
-development:
-  error_collector:
-    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
-  transaction_tracer:
-    record_sql: obfuscated
-    enabled: true
-    stack_trace_threshold: 0.5
-    transaction_threshold: 1.0
-  capture_params: false

data/test/multiverse/suites/net_http/net_http_test.rb

@@ -1,111 +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 "newrelic_rpm"
-require "http_client_test_cases"
-
-class NetHttpTest < Minitest::Test
-  include HttpClientTestCases
-
-  #
-  # Support for shared test cases
-  #
-
-  def client_name
-    "Net::HTTP"
-  end
-
-  def get_response(url=nil, headers={})
-    uri = default_uri
-    uri = URI.parse(url) unless url.nil?
-    path = uri.path.empty? ? '/' : uri.path
-
-    start(uri) { |http| http.get(path, headers) }
-  end
-
-  def get_response_multi(url, n)
-    uri = URI(url)
-    responses = []
-
-    start(uri) do |conn|
-      n.times do
-        req = Net::HTTP::Get.new(url)
-        responses << conn.request(req)
-      end
-    end
-
-    responses
-  end
-
-  def head_response
-    start(default_uri) { |http| http.head(default_uri.path) }
-  end
-
-  def post_response
-    start(default_uri) { |http| http.post(default_uri.path, "") }
-  end
-
-  def put_response
-    start(default_uri) { |http| http.put(default_uri.path, "") }
-  end
-
-  def delete_response
-    start(default_uri) { |http| http.delete(default_uri.path) }
-  end
-
-  def create_http(uri)
-    http = Net::HTTP.new(uri.host, uri.port)
-    if use_ssl?
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    end
-    http
-  end
-
-  def start(uri, &block)
-    http = create_http(uri)
-    http.start(&block)
-  end
-
-  def request_instance
-    http = Net::HTTP.new(default_uri.host, default_uri.port)
-    request = Net::HTTP::Get.new(default_uri.request_uri)
-    NewRelic::Agent::HTTPClients::NetHTTPRequest.new(http, request)
-  end
-
-  def response_instance(headers = {})
-    response = Net::HTTPResponse.new(nil, nil, nil)
-    headers.each do |k,v|
-      response[k] = v
-    end
-    response
-  end
-
-  #
-  # Net::HTTP specific tests
-  #
-  def test_get__simple
-    # Don't check this specific condition against SSL, since API doesn't support it
-    return if use_ssl?
-
-    Net::HTTP.get default_uri
-
-    assert_metrics_recorded([
-      'External/all',
-      'External/localhost/Net::HTTP/GET',
-      'External/allOther',
-      'External/localhost/all'
-    ])
-  end
-
-  # https://newrelic.atlassian.net/browse/RUBY-835
-  def test_direct_get_request_doesnt_double_count
-    http = create_http(default_uri)
-    http.request(Net::HTTP::Get.new(default_uri.request_uri))
-
-    assert_metrics_recorded(
-      'External/localhost/Net::HTTP/GET' => { :call_count => 1 })
-  end
-end