nunes 0.1.0

data/test/adapter_test.rb

@@ -0,0 +1,40 @@
+require "helper"
+
+class AdapterTest < ActiveSupport::TestCase
+  test "wrap for statsd" do
+    client_with_gauge_and_timing = Class.new do
+      def increment(*args); end
+      def gauge(*args); end
+      def timing(*args); end
+    end.new
+
+    adapter = Nunes::Adapter.wrap(client_with_gauge_and_timing)
+    assert_instance_of Nunes::Adapters::Default, adapter
+  end
+
+  test "wrap for instrumental" do
+    client_with_gauge_but_not_timing = Class.new do
+      def increment(*args); end
+      def gauge(*args); end
+    end.new
+
+    adapter = Nunes::Adapter.wrap(client_with_gauge_but_not_timing)
+    assert_instance_of Nunes::Adapters::TimingAliased, adapter
+  end
+
+  test "wrap for adapter" do
+    memory = Nunes::Adapters::Memory.new
+    adapter = Nunes::Adapter.wrap(memory)
+    assert_equal memory, adapter
+  end
+
+  test "wrap with hash" do
+    hash = {}
+    adapter = Nunes::Adapter.wrap(hash)
+    assert_instance_of Nunes::Adapters::Memory, adapter
+  end
+
+  test "wrap with nil" do
+    assert_raises(ArgumentError) { Nunes::Adapter.wrap(nil) }
+  end
+end

data/test/adapters/default_test.rb

@@ -0,0 +1,26 @@
+require "helper"
+require "minitest/mock"
+
+class DefaultAdapterTest < ActiveSupport::TestCase
+  test "passes increment along" do
+    mock = MiniTest::Mock.new
+    mock.expect :increment, nil, ["single", 1]
+    mock.expect :increment, nil, ["double", 2]
+
+    client = Nunes::Adapters::Default.new(mock)
+    client.increment("single")
+    client.increment("double", 2)
+
+    mock.verify
+  end
+
+  test "passes timing along" do
+    mock = MiniTest::Mock.new
+    mock.expect :timing, nil, ["foo", 23]
+
+    client = Nunes::Adapters::Default.new(mock)
+    client.timing("foo", 23)
+
+    mock.verify
+  end
+end

data/test/adapters/timing_aliased_test.rb

@@ -0,0 +1,26 @@
+require "helper"
+require "minitest/mock"
+
+class TimingAliasedAdapterTest < ActiveSupport::TestCase
+  test "passes increment along" do
+    mock = MiniTest::Mock.new
+    mock.expect :increment, nil, ["single", 1]
+    mock.expect :increment, nil, ["double", 2]
+
+    client = Nunes::Adapters::TimingAliased.new(mock)
+    client.increment("single")
+    client.increment("double", 2)
+
+    mock.verify
+  end
+
+  test "sends timing to gauge" do
+    mock = MiniTest::Mock.new
+    mock.expect :gauge, nil, ["foo", 23]
+
+    client = Nunes::Adapters::TimingAliased.new(mock)
+    client.timing("foo", 23)
+
+    mock.verify
+  end
+end

data/test/cache_instrumentation_test.rb

@@ -0,0 +1,79 @@
+require "helper"
+
+class CacheInstrumentationTest < ActiveSupport::TestCase
+  attr_reader :cache
+
+  setup :setup_subscriber, :setup_cache
+  teardown :teardown_subscriber, :teardown_cache
+
+  def setup_subscriber
+    @subscriber = Nunes::Subscribers::ActiveSupport.subscribe(adapter)
+  end
+
+  def teardown_subscriber
+    ActiveSupport::Notifications.unsubscribe @subscriber if @subscriber
+  end
+
+  def setup_cache
+    ActiveSupport::Cache::MemoryStore.instrument = true
+    @cache = ActiveSupport::Cache::MemoryStore.new
+  end
+
+  def teardown_cache
+    ActiveSupport::Cache::MemoryStore.instrument = nil
+    @cache = nil
+  end
+
+  test "cache_read miss" do
+    cache.read('foo')
+
+    assert_timer "active_support.cache_read"
+    assert_counter "active_support.cache_miss"
+  end
+
+  test "cache_read hit" do
+    cache.write('foo', 'bar')
+    adapter.clear
+    cache.read('foo')
+
+    assert_timer "active_support.cache_read"
+    assert_counter "active_support.cache_hit"
+  end
+
+  test "cache_generate" do
+    cache.fetch('foo') { |key| :generate_me_please }
+    assert_timer "active_support.cache_generate"
+  end
+
+  test "cache_fetch with hit" do
+    cache.write('foo', 'bar')
+    adapter.clear
+    cache.fetch('foo') { |key| :never_gets_here }
+
+    assert_timer "active_support.cache_fetch"
+    assert_timer "active_support.cache_fetch_hit"
+  end
+
+  test "cache_fetch with miss" do
+    cache.fetch('foo') { 'foo value set here' }
+
+    assert_timer "active_support.cache_fetch"
+    assert_timer "active_support.cache_generate"
+    assert_timer "active_support.cache_write"
+  end
+
+  test "cache_write" do
+    cache.write('foo', 'bar')
+    assert_timer "active_support.cache_write"
+  end
+
+  test "cache_delete" do
+    cache.delete('foo')
+    assert_timer "active_support.cache_delete"
+  end
+
+  test "cache_exist?" do
+    cache.exist?('foo')
+    assert_timer "active_support.cache_exist"
+  end
+end

data/test/controller_instrumentation_test.rb

@@ -0,0 +1,88 @@
+require "helper"
+
+class ControllerInstrumentationTest < ActionController::TestCase
+  tests PostsController
+
+  setup :setup_subscriber
+  teardown :teardown_subscriber
+
+  def setup_subscriber
+    @subscriber = Nunes::Subscribers::ActionController.subscribe(adapter)
+  end
+
+  def teardown_subscriber
+    ActiveSupport::Notifications.unsubscribe @subscriber if @subscriber
+  end
+
+  test "process_action" do
+    get :index
+
+    assert_response :success
+
+    assert_counter "action_controller.status.200"
+    assert_counter "action_controller.format.html"
+
+    assert_timer "action_controller.runtime"
+    assert_timer "action_controller.view_runtime"
+
+    assert_timer "action_controller.posts.index.runtime"
+    assert_timer "action_controller.posts.index.view_runtime"
+  end
+
+  test "send_data" do
+    get :some_data
+
+    assert_response :success
+
+    assert_counter "action_controller.status.200"
+
+    assert_timer "action_controller.runtime"
+    assert_timer "action_controller.view_runtime"
+
+    assert_timer "action_controller.posts.some_data.runtime"
+    assert_timer "action_controller.posts.some_data.view_runtime"
+  end
+
+  test "send_file" do
+    get :some_file
+
+    assert_response :success
+
+    assert_counter"action_controller.status.200"
+
+    assert_timer "action_controller.runtime"
+    assert_timer "action_controller.posts.some_file.runtime"
+
+    assert ! adapter.timer?("action_controller.view_runtime")
+    assert ! adapter.timer?("action_controller.posts.some_file.view_runtime")
+  end
+
+  test "redirect_to" do
+    get :some_redirect
+
+    assert_response :redirect
+
+    assert_counter "action_controller.status.302"
+
+    assert_timer "action_controller.runtime"
+    assert_timer "action_controller.posts.some_redirect.runtime"
+
+    assert_no_timer "action_controller.view_runtime"
+    assert_no_timer "action_controller.posts.some_redirect.view_runtime"
+  end
+
+  test "action with exception" do
+    get :some_boom rescue StandardError # catch the boom
+
+    assert_response :success
+
+    assert_counter "action_controller.exception.RuntimeError"
+    assert_counter "action_controller.format.html"
+
+    assert_timer "action_controller.runtime"
+    assert_timer "action_controller.posts.some_boom.runtime"
+
+    assert_no_timer "action_controller.view_runtime"
+    assert_no_timer "action_controller.posts.some_boom.view_runtime"
+  end
+end

data/test/fake_udp_socket_test.rb

@@ -0,0 +1,26 @@
+require "helper"
+
+class FakeUdpSocketTest < ActiveSupport::TestCase
+  test "timer boolean" do
+    socket = FakeUdpSocket.new
+    socket.send "action_controller.posts.index.runtime:2|ms"
+    assert_equal true,  socket.timer?("action_controller.posts.index.runtime")
+    assert_equal false, socket.timer?("action_controller.posts.index.faketime")
+  end
+
+  test "counter boolean" do
+    socket = FakeUdpSocket.new
+    socket.send "action_controller.status.200:1|c"
+    assert_equal true,  socket.counter?("action_controller.status.200")
+    assert_equal false, socket.counter?("action_controller.status.400")
+  end
+
+  test "send, recv and clear" do
+    socket = FakeUdpSocket.new
+    socket.send "foo"
+    socket.send "bar"
+    assert_equal "foo", socket.recv
+    socket.clear
+    assert_nil socket.recv
+  end
+end

data/test/helper.rb

@@ -0,0 +1,25 @@
+ENV["RAILS_ENV"] = "test"
+
+require "rails"
+require "rails/test_help"
+require "action_mailer"
+
+# require everything in the support directory
+root = Pathname(__FILE__).dirname.join("..").expand_path
+Dir[root.join("test/support/**/*.rb")].each { |f| require f }
+
+class ActionController::TestCase
+  include AdapterTestHelpers
+end
+
+class ActionMailer::TestCase
+  include AdapterTestHelpers
+end
+
+class ActiveSupport::TestCase
+  include AdapterTestHelpers
+end
+
+require "rails_app/config/environment"
+
+require "nunes"

data/test/instrumentable_test.rb

@@ -0,0 +1,100 @@
+require "helper"
+
+class InstrumentationTest < ActiveSupport::TestCase
+  attr_reader :thing_class
+
+  setup :setup_subscriber, :setup_class
+  teardown :teardown_subscriber, :teardown_class
+
+  def setup_subscriber
+    @subscriber = Nunes::Subscribers::Nunes.subscribe(adapter)
+  end
+
+  def teardown_subscriber
+    ActiveSupport::Notifications.unsubscribe @subscriber if @subscriber
+  end
+
+  def setup_class
+    @thing_class = Class.new {
+      extend Nunes::Instrumentable
+
+      def self.name
+        'Thing'
+      end
+
+      def yo(args = {})
+        :dude
+      end
+    }
+  end
+
+  def teardown_class
+    @thing_class = nil
+  end
+
+  test "adds methods when extended" do
+    assert thing_class.respond_to?(:instrument_method_time)
+  end
+
+  test "attempting to instrument time for method twice" do
+    thing_class.instrument_method_time :yo
+
+    assert_raises(ArgumentError, "already instrumented yo for Thing") do
+      thing_class.instrument_method_time :yo
+    end
+  end
+
+  test "instrument_method_time" do
+    thing_class.instrument_method_time :yo
+
+    event = slurp_events { thing_class.new.yo(some: 'thing') }.last
+
+    assert_not_nil event, "No events were found."
+    assert_equal "thing.yo", event.payload[:metric]
+    assert_equal [{some: "thing"}], event.payload[:arguments]
+    assert_equal :dude, event.payload[:result]
+    assert_in_delta 0, event.duration, 0.1
+
+    assert_timer "thing.yo"
+  end
+
+  test "instrument_method_time with custom name in hash" do
+    thing_class.instrument_method_time :yo, name: 'Thingy.yohoho'
+
+    event = slurp_events { thing_class.new.yo(some: 'thing') }.last
+
+    assert_not_nil event, "No events were found."
+    assert_equal "thingy.yohoho", event.payload[:metric]
+
+    assert_timer "thingy.yohoho"
+  end
+
+  test "instrument_method_time with custom name as string" do
+    thing_class.instrument_method_time :yo, 'Thingy.yohoho'
+
+    event = slurp_events { thing_class.new.yo(some: 'thing') }.last
+
+    assert_not_nil event, "No events were found."
+    assert_equal "thingy.yohoho", event.payload[:metric]
+
+    assert_timer "thingy.yohoho"
+  end
+
+  test "instrument_method_time with custom payload" do
+    thing_class.instrument_method_time :yo, payload: {pay: "loadin"}
+
+    event = slurp_events { thing_class.new.yo(some: 'thing') }.last
+
+    assert_not_nil event, "No events were found."
+    assert_equal "loadin", event.payload[:pay]
+
+    assert_timer "thing.yo"
+  end
+
+  def slurp_events(&block)
+    events = []
+    callback = lambda { |*args| events << ActiveSupport::Notifications::Event.new(*args) }
+    ActiveSupport::Notifications.subscribed(callback, Nunes::Instrumentable::MethodTimeEventName, &block)
+    events
+  end
+end

data/test/mailer_instrumentation_test.rb

@@ -0,0 +1,26 @@
+require "helper"
+
+class MailerInstrumentationTest < ActionMailer::TestCase
+  tests PostMailer
+
+  setup :setup_subscriber
+  teardown :teardown_subscriber
+
+  def setup_subscriber
+    @subscriber = Nunes::Subscribers::ActionMailer.subscribe(adapter)
+  end
+
+  def teardown_subscriber
+    ActiveSupport::Notifications.unsubscribe @subscriber if @subscriber
+  end
+
+  test "deliver" do
+    PostMailer.created.deliver
+    assert_timer "action_mailer.deliver.post_mailer"
+  end
+
+  test "receive" do
+    PostMailer.receive PostMailer.created
+    assert_timer "action_mailer.receive.post_mailer"
+  end
+end