scout_apm 2.6.10 → 3.0.0.pre0

data/test/unit/instruments/active_record_test.rb

@@ -1,40 +0,0 @@
-require 'test_helper'
-require 'sqlite3'
-require 'active_record'
-
-begin
-  require 'octoshark'
-rescue LoadError
-  # Ignore
-end
-
-class ActiveRecordTest < Minitest::Test
-  def database_path
-    File.expand_path('test.sqlite3', DATA_FILE_DIR)
-  end
-
-  def setup
-    database = SQLite3::Database.new(database_path)
-    database.execute("DROP TABLE IF EXISTS users;")
-    database.execute("CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(100));")
-
-    ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => database_path)
-  end
-
-  class User < ActiveRecord::Base
-  end
-
-  def test_instrumentation
-    recorder = FakeRecorder.new
-    agent_context.recorder = recorder
-
-    instrument = ScoutApm::Instruments::ActiveRecord.new(agent_context)
-    instrument.install
-
-    ScoutApm::Tracer.instrument("Controller", "foo/bar") do
-      user = User.create
-    end
-
-    assert 1, recorder.requests.size
-  end
-end

data/test/unit/instruments/net_http_test.rb

@@ -1,27 +0,0 @@
-require 'test_helper'
-
-require 'scout_apm/instruments/net_http'
-
-require 'addressable/uri'
-
-class NetHttpTest < Minitest::Test
-  def setup
-    @context = ScoutApm::AgentContext.new
-    ScoutApm::Instruments::NetHttp.new(@context).install
-  end
-
-  def test_request_scout_description_for_uri
-    if RUBY_VERSION <= '1.9.3'
-      req = Net::HTTP::Get.new('/here')
-    else
-      req = Net::HTTP::Get.new(URI('http://example.org/here'))
-    end
-
-    assert_equal '/here', Net::HTTP.new('').request_scout_description(req)
-  end
-
-  def test_request_scout_description_for_addressable
-    req = Net::HTTP::Get.new(Addressable::URI.parse('http://example.org/here'))
-    assert_equal '/here', Net::HTTP.new('').request_scout_description(req)
-  end
-end

data/test/unit/instruments/percentile_sampler_test.rb

@@ -1,133 +0,0 @@
-require 'test_helper'
-
-require 'scout_apm/instruments/percentile_sampler'
-
-class PercentileSamplerTest < Minitest::Test
-  PercentileSampler = ScoutApm::Instruments::PercentileSampler
-  HistogramReport = ScoutApm::Instruments::HistogramReport
-
-  attr_reader :subject
-
-  def setup
-    @context = ScoutApm::AgentContext.new
-    @subject = PercentileSampler.new(@context)
-  end
-
-  def test_initialize_with_logger_and_histogram_set
-    assert_equal subject.logger, @context.logger
-    assert_equal subject.histograms, @context.request_histograms_by_time
-  end
-
-  def test_implements_instrument_interface
-    assert subject.respond_to?(:human_name)
-  end
-
-  def test_percentiles_returns_one_percentile_per_endpoint_at_time
-    histograms[time].add("foo", 10)
-    histograms[time].add("bar", 15)
-    histograms[time2].add("baz", 15)
-
-    assert_equal subject.percentiles(time).length, 2
-    assert_equal subject.percentiles(time2).length, 1
-  end
-
-  def test_percentiles_clears_time_from_hash
-    histograms[time].add("foo", 10)
-    histograms[time2].add("baz", 15)
-
-    subject.percentiles(time)
-
-    assert_false histograms.key?(time)
-    assert       histograms.key?(time + 10)
-  end
-
-  def test_percentiles_returns_histogram_reports
-    histograms[time].add("foo", 10)
-
-    assert subject.percentiles(time).
-      all?{ |item| item.is_a?(HistogramReport) }
-  end
-
-  def test_percentiles_returns_correct_histogram_report
-    histograms[time].add("foo", 100)
-    histograms[time].add("foo", 200)
-    histograms[time].add("foo", 100)
-    histograms[time].add("foo", 300)
-
-    report = subject.percentiles(time).first
-    histogram = report.histogram
-
-    assert_equal "foo", report.name
-    assert_equal 4, histogram.total
-    assert_equal [[2, 100], [1, 200], [1, 300]],
-      histogram.bins.map{|bin| [bin.count, bin.value] }
-  end
-
-  def test_metrics_saves_histogram_to_store
-    store = mock
-    store.expects(:track_histograms!)
-    subject.metrics(ScoutApm::StoreReportingPeriodTimestamp.new(time), store)
-  end
-
-
-  ################################################################################
-  # HistogramReport Test
-  ################################################################################
-  def test_histogram_report_combine_refuses_to_combine_mismatched_name
-    assert_raises { HistogramReport.new("foo", histogram).combine!(HistogramReport.new("bar", histogram)) }
-  end
-
-  def test_histogram_report_merge_keeps_name
-    report1 = HistogramReport.new("foo", histogram)
-    report2 = HistogramReport.new("foo", histogram)
-    combined = report1.combine!(report2)
-
-    assert "foo", combined.name
-  end
-
-  def test_histogram_report_combine_merges_histograms
-    histogram1 = histogram
-    histogram2 = histogram
-    histogram1.add(1)
-    histogram1.add(2)
-    histogram2.add(2)
-    histogram2.add(3)
-
-    report1 = HistogramReport.new("foo", histogram1)
-    report2 = HistogramReport.new("foo", histogram2)
-    combined = report1.combine!(report2)
-
-    assert_equal 4, combined.histogram.total
-    assert_equal [[1, 1], [2, 2], [1, 3]],
-      combined.histogram.bins.map{|bin| [bin.count, bin.value.to_i] }
-  end
-
-  ################################################################################
-  # Test Helpers
-  ################################################################################
-  def logger
-    @logger ||= begin
-                  @logger_io = StringIO.new
-                  Logger.new(@logger_io)
-                end
-  end
-
-  def histograms
-    @context.request_histograms_by_time
-  end
-
-  def histogram
-    max_bins = 20
-    ScoutApm::NumericHistogram.new(max_bins)
-  end
-
-  # An arbitrary time
-  def time
-    @time ||= Time.now
-  end
-
-  def time2
-    time + 10
-  end
-end
-

data/test/unit/layer_children_set_test.rb

@@ -1,97 +0,0 @@
-require 'test_helper'
-require 'scout_apm/layer_children_set'
-
-class LayerChildrenSetTest < Minitest::Test
-  SET = ScoutApm::LayerChildrenSet
-
-  def test_limit_default
-    assert_equal SET::DEFAULT_UNIQUE_CUTOFF, SET.new.unique_cutoff
-  end
-
-  # Add 5, make sure they're all in the children list we get back.
-  def test_add_layer_before_limit
-    s = SET.new(5)
-
-    5.times do
-      s << make_layer("LayerType", "LayerName")
-    end
-
-    children = s.to_a
-    assert_equal 5, children.size
-
-    # Don't care about order
-    (0..4).each do |i|
-      assert children.include?(lookup_layer(i))
-    end
-  end
-
-  def test_add_layer_after_limit
-    s = SET.new(5)
-
-    10.times do
-      s << make_layer("LayerType", "LayerName")
-    end
-
-    children = s.to_a
-    # 6 = 5 real ones + 1 merged.
-    assert_equal 6, children.size
-
-    # Don't care about order
-    (0..4).each do |i|
-      assert children.include?(lookup_layer(i))
-    end
-
-    # Don't care about order
-    (5..9).each do |i|
-      assert ! children.include?(lookup_layer(i))
-    end
-
-    limited_layer = children.last
-    assert_equal ScoutApm::LimitedLayer, limited_layer.class
-    assert_equal 5, limited_layer.count
-  end
-
-  def test_add_layer_with_different_type_after_limit
-    s = SET.new(5)
-
-    # Add 20 items
-    10.times do
-      s << make_layer("LayerType", "LayerName")
-      s << make_layer("DifferentLayerType", "LayerName")
-    end
-
-    children = s.to_a
-
-    # Tyo types, so 2 distinct limitdlayer objects
-    limited_layers = children.select{ |l| ScoutApm::LimitedLayer === l }
-    assert_equal 2, limited_layers.length
-
-    # 5 unchanged children each for the two layer types, plus the 2 limitd when each overran their limit
-    assert_equal 12, children.length
-    limited_layers.each { |ml| assert_equal 5, ml.count }
-  end
-
-  def test_works_with_marshal
-    s = SET.new(5)
-    10.times do
-      s << make_layer("LayerType", "LayerName")
-    end
-
-    Marshal.dump(s)
-  end
-
-  #############
-  #  Helpers  #
-  #############
-
-  def make_layer(type, name)
-    @made_layers ||= []
-    l = ScoutApm::Layer.new(type, name)
-    @made_layers << l
-    l
-  end
-
-  def lookup_layer(i)
-    @made_layers[i]
-  end
-end

data/test/unit/layer_converters/depth_first_walker_test.rb

@@ -1,70 +0,0 @@
-require 'test_helper'
-
-module ScoutApm
-class DepthFirstWalkerTest < Minitest::Test
-  def test_walk_single_node_calls_callbacks_in_order
-    calls = []
-    layer = Layer.new("A", "x")
-
-    walker = LayerConverters::DepthFirstWalker.new(layer)
-    walker.before { |l| calls << :before }
-    walker.after { |l| calls << :after }
-    walker.on { |l| calls << :on }
-
-    walker.walk
-
-    assert_equal [:before, :on, :after], calls
-  end
-
-  # Tree looks like:
-  #    A
-  #    |
-  #    B
-  #  / \ \
-  #  C  D E
-  # / \
-  # F  G
-  def test_walk_interesting_tree
-    # The test could be rewritten to support 1.8.7, but it would likely be much
-    # harder to read.
-    skip "Lack of set ordering in Ruby 1.8.7 prevents this test from running correctly" if RUBY_VERSION.start_with?("1.8.")
-
-    calls = []
-    a = Layer.new("A", "x")
-    b = Layer.new("B", "x")
-    c = Layer.new("C", "x")
-    d = Layer.new("D", "x")
-    e = Layer.new("E", "x")
-    f = Layer.new("F", "x")
-    g = Layer.new("G", "x")
-    a.add_child(b)
-    b.add_child(c)
-    b.add_child(d)
-    b.add_child(e)
-    c.add_child(f)
-    c.add_child(g)
-
-    root_layer = a
-
-    walker = LayerConverters::DepthFirstWalker.new(root_layer)
-    walker.before { |l| calls << "#{l.type} before" }
-    walker.after { |l| calls << "#{l.type} after" }
-    walker.on { |l| calls << "#{l.type} on" }
-
-    walker.walk
-
-    assert_equal [
-      "A before", "A on", # before & on always line up next to each other
-      "B before", "B on",
-      "C before", "C on",
-      "F before", "F on", "F after", # leaf nodes run all 3
-      "G before", "G on", "G after",
-      "C after", # once all children are done, do a node's after
-      "D before", "D on", "D after",
-      "E before", "E on", "E after",
-      "B after",
-      "A after"
-    ], calls
-  end
-end
-end

data/test/unit/layer_converters/metric_converter_test.rb

@@ -1,22 +0,0 @@
-require 'test_helper'
-require File.join(File.dirname(__FILE__), 'stubs')
-
-module ScoutApm
-module LayerConverters
-class MetricConverterTest < Minitest::Test
-  include Stubs
-
-  def test_register_adds_hooks
-    mc = MetricConverter.new(agent_context, faux_request, faux_layer_finder, faux_store)
-    faux_walker.expects(:on)
-    mc.register_hooks(faux_walker)
-  end
-
-  def test_record
-    mc = MetricConverter.new(agent_context, faux_request, faux_layer_finder, faux_store)
-    faux_store.expects(:track!)
-    mc.record!
-  end
-end
-end
-end

data/test/unit/layer_converters/stubs.rb

@@ -1,33 +0,0 @@
-####################################
-#  Stubs for LayerConverter Tests  #
-####################################
-module ScoutApm
-  module LayerConverters
-    module Stubs
-      def faux_walker(subscope_stubs = true)
-        @w ||= stub
-
-        if subscope_stubs && !@w_set_subscope_stubs
-          @w_set_subscope_stubs = true
-          @w.expects(:before)
-          @w.expects(:after)
-        end
-        @w
-      end
-
-      def faux_request
-        @req ||= stub(:root_layer => stub)
-      end
-
-      def faux_layer_finder
-        @layer_finder ||= stub
-        @layer_finder.stubs(:scope => stub)
-        @layer_finder
-      end
-
-      def faux_store
-        @store ||= stub
-      end
-    end
-  end
-end

data/test/unit/limited_layer_test.rb

@@ -1,53 +0,0 @@
-require 'test_helper'
-require 'ostruct'
-
-class LimitedLayerTest < Minitest::Test
-
-  def test_counts_while_absorbing
-    ll = ScoutApm::LimitedLayer.new("ActiveRecord")
-    assert_equal 0, ll.count
-
-    ll.absorb faux_layer("ActiveRecord", "User#Find", 2, 1, 200, 100)
-    assert_equal 1, ll.count
-
-    ll.absorb faux_layer("ActiveRecord", "User#Find", 2, 1, 200, 100)
-    assert_equal 2, ll.count
-  end
-
-  def test_sums_values_while_absorbing
-    ll = ScoutApm::LimitedLayer.new("ActiveRecord")
-
-    ll.absorb faux_layer("ActiveRecord", "User#Find", 2, 1, 200, 100)
-    assert_equal 1, ll.total_exclusive_time
-    assert_equal 2, ll.total_call_time
-    assert_equal 100, ll.total_exclusive_allocations
-    assert_equal 200, ll.total_allocations
-
-
-    ll.absorb faux_layer("ActiveRecord", "User#Find", 4, 3, 400, 300)
-    assert_equal 4, ll.total_exclusive_time           # 3 + 1
-    assert_equal 6, ll.total_call_time                # 4 + 2
-    assert_equal 400, ll.total_exclusive_allocations  # 300 + 100
-    assert_equal 600, ll.total_allocations            # 400 + 200
-  end
-
-  def test_the_name
-    ll = ScoutApm::LimitedLayer.new("ActiveRecord")
-    assert_equal "ActiveRecord/Limited", ll.legacy_metric_name
-  end
-
-  #############
-  #  Helpers  #
-  #############
-
-  def faux_layer(type, name, tct, tet, a_tct, a_tet)
-    OpenStruct.new(
-      :type => type,
-      :name => name,
-      :total_call_time => tct,
-      :total_exclusive_time => tet,
-      :total_allocations => a_tct,
-      :total_exclusive_allocations => a_tet
-    )
-  end
-end

data/test/unit/logger_test.rb

@@ -1,69 +0,0 @@
-require 'test_helper'
-require 'fileutils'
-
-require 'scout_apm/logger'
-
-class LoggerTest < Minitest::Test
-  def setup
-    @env_root = Pathname.new(File.expand_path(File.join(File.dirname(__FILE__), "..", "..")))
-    FileUtils.mkdir_p(@env_root + "log")
-  end
-
-  def test_detect_stdout
-    logger = ScoutApm::Logger.new("", { :log_file_path => "STDOUT"})
-    assert logger.stdout?
-    assert_equal STDOUT, logger.log_destination
-
-    # and lowercase
-    logger = ScoutApm::Logger.new("", { :log_file_path => "stdout"})
-    assert logger.stdout?
-    assert_equal STDOUT, logger.log_destination
-  end
-
-  def test_force_stdout
-    logger = ScoutApm::Logger.new("", { :stdout => true })
-    assert logger.stdout?
-    assert_equal STDOUT, logger.log_destination
-  end
-
-  def test_pick_log_file_with_no_options
-    logger = ScoutApm::Logger.new(@env_root, { })
-    assert_equal (@env_root + "log" + "scout_apm.log").to_s, logger.log_destination
-  end
-
-  def test_pick_log_file_with_different_dir
-    logger = ScoutApm::Logger.new(@env_root, { :log_file_path => "/tmp" })
-    assert_equal "/tmp/scout_apm.log", logger.log_destination
-  end
-
-  def test_pick_log_file_invalid_dir
-    logger = ScoutApm::Logger.new(@env_root, { :log_file_path => "/not_a_real_dir" })
-    assert_equal STDOUT, logger.log_destination
-  end
-
-  def test_pick_log_dir_not_writable
-    Dir.mktmpdir { |dir|
-      # An unwritable dir
-      FileUtils.chmod(0000, dir)
-      logger = ScoutApm::Logger.new(@env_root, { :log_file_path => dir })
-      assert_equal STDOUT, logger.log_destination
-
-      # so it can be deleted
-      FileUtils.chmod(0700, dir)
-    }
-  end
-
-  def test_set_log_level
-    logger = ScoutApm::Logger.new(@env_root, { :log_level => "debug" })
-    assert_equal ::Logger::DEBUG, logger.log_level
-  end
-
-  def test_set_log_level_after
-    logger = ScoutApm::Logger.new(@env_root, { :log_level => "debug" })
-    logger.log_level = "info"
-    assert_equal ::Logger::INFO, logger.log_level
-
-    logger.log_level = ::Logger::ERROR
-    assert_equal ::Logger::ERROR, logger.log_level
-  end
-end

data/test/unit/remote/test_message.rb

@@ -1,13 +0,0 @@
-require 'test_helper'
-
-class MessageTest < Minitest::Test
-  def test_message_encode_decode_roundtrip
-    message = ScoutApm::Remote::Message.new('type', 'command', ['arg'])
-    encoded = message.encode
-    decoded = ScoutApm::Remote::Message.decode(encoded)
-    assert_equal message.type, decoded.type
-    assert_equal message.command, decoded.command
-    assert_equal message.args, decoded.args
-  end
-end
-

data/test/unit/remote/test_router.rb

@@ -1,33 +0,0 @@
-require 'test_helper'
-
-class RouterTest < Minitest::Test
-  def test_router_handles_record
-    recorder = stub
-    router = ScoutApm::Remote::Router.new(recorder, logger)
-    message = ScoutApm::Remote::Message.new("record", "foo", 1, 2).encode
-
-    recorder.expects(:foo).with(1, 2)
-
-    router.handle(message)
-  end
-
-  def test_router_raises_on_unknown_types
-    recorder = stub
-    router = ScoutApm::Remote::Router.new(recorder, logger)
-    message = ScoutApm::Remote::Message.new("something_else", "foo", 1, 2).encode
-
-    recorder.expects(:foo).never
-    assert_raises do
-      router.handle(message)
-    end
-  end
-
-  def logger
-    @logger ||= Logger.new(logger_io)
-  end
-
-  def logger_io
-    @logger_io ||= StringIO.new
-  end
-end
-

data/test/unit/remote/test_server.rb

@@ -1,15 +0,0 @@
-require 'test_helper'
-
-class TestRemoteServer < Minitest::Test
-  def test_start_and_bind
-    bind = "127.0.0.1"
-    port = 8938
-    router = stub(:router)
-    logger_io = StringIO.new
-    server = ScoutApm::Remote::Server.new(bind, port, router, Logger.new(logger_io))
-
-    server.start
-    sleep 0.01 # Let the server finish starting. The assert should instead allow a time
-    assert server.running?
-  end
-end

data/test/unit/request_histograms_test.rb

@@ -1,17 +0,0 @@
-require 'test_helper'
-
-require 'scout_apm/request_histograms'
-
-class RequestHistogramsTest < Minitest::Test
-  def test_as_json_without_activesupport
-    rh = ScoutApm::RequestHistograms.new
-
-    rh.add("foo", 1)
-    rh.add("foo", 2)
-    rh.add("bar", 3)
-
-    j = rh.as_json
-    assert_equal 2, j.size
-    assert_equal ["bar", "foo"], j.keys.sort
-  end
-end