mmtrix_rpm 1.0.0.1

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

@@ -0,0 +1,241 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/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 Mmtrix::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

@@ -0,0 +1,176 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/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 Mmtrix::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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'mongo'
+require 'mmtrix_rpm'
+require 'mmtrix/agent/datastores/mongo'
+require 'securerandom'
+
+if Mmtrix::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 Mmtrix::Agent::Instrumentation::MongoConnectionTest
+    include Mongo
+    include ::Mmtrix::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'}
+
+      Mmtrix::Agent::Transaction.stubs(:recording_web_transaction?).returns(true)
+      Mmtrix::Agent.drop_buffered_data
+    end
+
+    def teardown
+      Mmtrix::Agent.drop_buffered_data
+      @database.drop_collection(@collection_name)
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'mongo'
+require 'mmtrix_rpm'
+require 'mmtrix/agent/datastores/mongo'
+require 'securerandom'
+
+if Mmtrix::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 Mmtrix::Agent::Instrumentation::MongoInstrumentationTest < Minitest::Test
+    include Mongo
+    include ::Mmtrix::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'}
+
+      Mmtrix::Agent::Transaction.stubs(:recording_web_transaction?).returns(true)
+      Mmtrix::Agent.drop_buffered_data
+    end
+
+    def teardown
+      Mmtrix::Agent.drop_buffered_data
+      @database.drop_collection(@collection_name)
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'mongo'
+require 'mmtrix_rpm'
+require 'mmtrix/agent/datastores/mongo'
+
+if !Mmtrix::Agent::Datastores::Mongo.is_supported_version?
+  class Mmtrix::Agent::Instrumentation::MongoInstrumentationTest < Minitest::Test
+    include Mongo
+
+    def setup
+      @database_name = "multiverse"
+      @collection_name = "tribbles-#{SecureRandom.hex(16)}"
+      @tribble = {'name' => 'soterios johnson'}
+
+      setup_collection
+
+      Mmtrix::Agent.drop_buffered_data
+    end
+
+    def teardown
+      Mmtrix::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 Mmtrix::Agent::Datastores::Mongo.is_version2?
+      include Mongo2xUnsupported
+    else
+      include Mongo1xUnsupported
+    end
+  end
+end

data/test/multiverse/suites/net_http/Envfile

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

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

@@ -0,0 +1,18 @@
+---
+development:
+  error_collector:
+    enabled: true
+  apdex_t: 0.5
+  ssl: false
+  monitor_mode: true
+  license_key: bootstrap_mmtrix_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

@@ -0,0 +1,111 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix"s license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require "net/http"
+require "mmtrix_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)
+    Mmtrix::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://mmtrix.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