nunes 0.1.0 → 0.2.0

data/Changelog.md

@@ -0,0 +1,14 @@
+# 0.2.0
+
+## Backwards Compatibility Break
+
+* No longer using the inflector to pretty up metric names. This means that when you upgrade from 0.1 and 0.2 some metrics will change names.
+* Namespaced several of the stats to make them easier to graph.
+
+## Fixed
+
+* Instrumenting namespaced controllers
+
+# 0.1.0
+
+* Initial release.

data/Gemfile

@@ -9,3 +9,7 @@ gem "rake"
 group :watch do
   gem "rb-fsevent", require: false
 end
+
+group :bench do
+  gem "rblineprof"
+end

data/README.md

@@ -1,4 +1,4 @@
-# Nunes
+# nunes
 
 The friendly gem that instruments everything for you, like I would if I could.
 
@@ -10,7 +10,7 @@ Because I don't work for you, but even that could not stop me from trying to mak
 
 Add this line to your application's Gemfile:
 
-    gem 'nunes'
+    gem "nunes"
 
 Or install it yourself as:
 
@@ -18,28 +18,31 @@ Or install it yourself as:
 
 ## Usage
 
-nunes works out of the box with statsd and instrument_agent. All you need to do is subscribe using an instance of statsd or instrumental's agent and you are good to go.
+nunes works out of the box with [instrumental app](http://instrumentalapp.com) (my person favorite) and [statsd](https://github.com/reinh/statsd). All you need to do is subscribe using an instance of statsd or instrumental's agent and you are good to go.
 
-### With Statsd
+### With Instrumental
 
 ```ruby
-require 'nunes'
+require "nunes"
+I = Instrument::Agent.new(...)
+Nunes.subscribe(I)
+```
+
+### With Statsd
 
+```ruby
+require "nunes"
 statsd = Statsd.new(...)
 Nunes.subscribe(statsd)
 ```
 
-### With Instrumental
+### With Some Other Service
 
-```ruby
-require 'nunes'
-I = Instrument::Agent.new(...)
-Nunes.subscribe(I)
-```
+If you would like for nunes to work with some other service, you can easily make an adapter. Check out the [existing adapters](https://github.com/jnunemaker/nunes/tree/master/lib/nunes/adapters) for examples. The key is to inherit from `Nunes::Adapter` and then convert the `increment` and `timing` methods to whatever the service requires.
 
 ## What Can I Do For You?
 
-If you are using nunes with rails, out of the box, I'll subscribe to Actve Support's notifications for:
+If you are using nunes with Rails, I will subscribe to the following events:
 
 * `process_action.action_controller`
 * `render_template.action_view`
@@ -56,39 +59,44 @@ If you are using nunes with rails, out of the box, I'll subscribe to Actve Suppo
 
 Whoa! You would do all that for me? Yep, I would. Because I care. Deeply.
 
-Based on those events, you'll get metrics like this in statsd and instrumental:
+Based on those events, you'll get metrics like this in instrumental and statsd:
 
 #### Counters
 
 * `action_controller.status.200`
 * `action_controller.format.html`
 * `action_controller.exception.RuntimeError` - where RuntimeError is the class of any exceptions that occur while processing a controller's action.
-* `active_support.cache_hit`
-* `active_support.cache_miss`
+* `active_support.cache.hit`
+* `active_support.cache.miss`
 
 #### Timers
 
-* `action_controller.runtime`
-* `action_controller.view_runtime`
-* `action_controller.db_runtime`
-* `action_controller.posts.index.runtime` - where `posts` is the controller and `index` is the action
-* `action_view.app.views.posts.index.html.erb` - where `app.views.posts.index.html.erb` is the path of the view file
-* `action_view.app.views.posts._post.html.erb` - I can even do partials! woot woot!
-* `action_mailer.deliver.post_mailer` - where `post_mailer` is the name of the mailer
-* `action_mailer.receive.post_mailer` - where `post_mailer` is the name of the mailer
+* `action_controller.runtime.total`
+* `action_controller.runtime.view`
+* `action_controller.runtime.db`
+* `action_controller.controller.PostsController.index.runtime.total`
+* `action_controller.controller.PostsController.index.runtime.view`
+* `action_controller.controller.PostsController.index.runtime.db`
+* `action_view.template.app.views.posts.index.html.erb` - where `app.views.posts.index.html.erb` is the path of the view file
+* `action_view.partial.app.views.posts._post.html.erb` - I can even do partials! woot woot!
+* `action_mailer.deliver.PostMailer`
+* `action_mailer.receive.PostMailer`
 * `active_record.sql`
-* `active_record.sql.select` - also supported are insert, update, delete, transaction_begin and transaction_commit
-* `active_support.cache_read`
-* `active_support.cache_generate`
-* `active_support.cache_fetch`
-* `active_support.cache_fetch_hit`
-* `active_support.cache_write`
-* `active_support.cache_delete`
-* `active_support.cache_exist`
+* `active_record.sql.select`
+* `active_record.sql.insert`
+* `active_record.sql.update`
+* `active_record.sql.delete`
+* `active_support.cache.read`
+* `active_support.cache.fetch`
+* `active_support.cache.fetch_hit`
+* `active_support.cache.fetch_generate`
+* `active_support.cache.write`
+* `active_support.cache.delete`
+* `active_support.cache.exist`
 
 ### But wait, there's more!!!
 
-In addition to doing all that work for you out of the box, I also allow you to wrap your own code with instrumentation. I know, I know, sounds too good to be true.
+In addition to doing all that automagical work for you, I also allow you to wrap your own code with instrumentation. I know, I know, sounds too good to be true.
 
 ```ruby
 class User < ActiveRecord::Base
@@ -106,7 +114,7 @@ user = User.new(name: 'NUNES!')
 user.save
 ```
 
-An event named `instrument_method_time.nunes` will be generated, which in turn is subscribed to and sent to whatever you used to send instrumentation to (statsd, instrumental, etc.). The metric name will default to class.method. For the example above, the metric name would be `user.save`. No fear, you can customize this.
+An event named `instrument_method_time.nunes` will be generated, which in turn is subscribed to and sent to whatever you used to send instrumentation to (statsd, instrumental, etc.). The metric name will default to class.method. For the example above, the metric name would be `User.save`. No fear, you can customize this.
 
 ```ruby
 class User < ActiveRecord::Base
@@ -141,6 +149,28 @@ end
 
 If you subscribe to the event on your own, say to log some things, you'll get a key named `:pay` with a value of `"loading"` in the event's payload. Pretty neat, eh?
 
+## `script/bootstrap`
+
+This script will get all the dependencies ready so you can start hacking on nunes.
+
+```
+# to learn more about script/bootstrap
+script/bootstrap help
+```
+
+## `script/test`
+
+For your convenience, there is a script to run the tests. It will also perform `script/bootstrap`, which bundles and all that jazz.
+
+```
+# to learn more about script test
+script/test help
+```
+
+## `script/watch`
+
+If you are like me, you are too lazy to continually run `script/test`. For this scenario, I have included `script/watch`, which will run `script/test` automatically anytime a relevant file changes.
+
 ## Contributing
 
 1. Fork it

data/lib/nunes.rb

@@ -1,7 +1,6 @@
 require "nunes/instrumentable"
 
 require "nunes/adapters/memory"
-require "nunes/adapters/default"
 require "nunes/adapters/timing_aliased"
 
 require "nunes/subscriber"

data/lib/nunes/adapter.rb

@@ -6,29 +6,27 @@ module Nunes
     #
     # Returns Nunes::Adapter instance.
     def self.wrap(client)
-      if client.nil?
-        raise ArgumentError.new("client cannot be nil")
-      end
+      raise ArgumentError, "client cannot be nil" if client.nil?
+      return client if client.is_a?(self)
 
-      if client.is_a?(self)
-        return client
-      end
+      adapter = adapters.detect { |adapter| adapter.wraps?(client) }
 
-      if client.is_a?(Hash)
-        return Adapters::Memory.new(client)
+      if adapter.nil?
+        raise ArgumentError,
+          "I have no clue how to wrap what you've given me (#{client.inspect})"
       end
 
-      has_increment = client.respond_to?(:increment)
-      has_timing = client.respond_to?(:timing)
-      has_gauge = client.respond_to?(:gauge)
+      adapter.new(client)
+    end
 
-      if has_increment && has_timing
-        Adapters::Default.new(client)
-      elsif has_increment && has_gauge && !has_timing
-        Adapters::TimingAliased.new(client)
-      else
-        raise "I have no clue how to wrap what you've given me (#{client.inspect})"
-      end
+    # Private
+    def self.wraps?(client)
+      client.respond_to?(:increment) && client.respond_to?(:timing)
+    end
+
+    # Private
+    def self.adapters
+      [Nunes::Adapter, *subclasses]
     end
 
     # Private
@@ -44,13 +42,35 @@ module Nunes
     # Internal: Increment a metric by a value. Override in subclass if client
     # interface does not match.
     def increment(metric, value = 1)
-      @client.increment metric, value
+      @client.increment prepare(metric), value
     end
 
     # Internal: Record a metric's duration. Override in subclass if client
     # interface does not match.
     def timing(metric, duration)
-      @client.timing metric, duration
+      @client.timing prepare(metric), duration
+    end
+
+    # Private: What Ruby uses to separate namespaces.
+    ReplaceRegex = /[^a-z0-9\-_]+/i
+
+    # Private: The default metric namespace separator.
+    Separator = "."
+
+    RegexSeparator = Regexp.escape(Separator)
+
+    # Private: Regex to match metric ending with separator.
+    StartsOrEndsWithSeparator = /\A#{RegexSeparator}|#{RegexSeparator}\Z/
+
+    # Private
+    Nothing = ""
+
+    # Private: Prepare a metric name before it is sent to the adapter's client.
+    def prepare(metric)
+      metric = metric.to_s.gsub(ReplaceRegex, Separator)
+      metric.squeeze!(Separator)
+      metric.gsub!(StartsOrEndsWithSeparator, Nothing)
+      metric
     end
   end
 end

data/lib/nunes/adapters/memory.rb

@@ -5,17 +5,21 @@ module Nunes
     # Internal: Memory backend for recording instrumentation calls. This should
     # never need to be used directly by a user of the gem.
     class Memory < ::Nunes::Adapter
+      def self.wraps?(client)
+        client.is_a?(Hash)
+      end
+
       def initialize(client = nil)
         @client = client || {}
         clear
       end
 
       def increment(metric, value = 1)
-        counters << [metric, value]
+        counters << [prepare(metric), value]
       end
 
       def timing(metric, value)
-        timers << [metric, value]
+        timers << [prepare(metric), value]
       end
 
       # Internal: Returns Array of any recorded timers with durations.

data/lib/nunes/adapters/timing_aliased.rb

@@ -8,9 +8,15 @@ module Nunes
     # adapter their gauge interface to the timing one used internally in the
     # gem. This should never need to be used directly by a user of the gem.
     class TimingAliased < ::Nunes::Adapter
+      def self.wraps?(client)
+        client.respond_to?(:increment) &&
+          client.respond_to?(:gauge) &&
+          !client.respond_to?(:timing)
+      end
+
       # Internal: Adapter timing to gauge.
       def timing(metric, duration)
-        @client.gauge metric, duration
+        @client.gauge prepare(metric), duration
       end
     end
   end

data/lib/nunes/instrumentable.rb

@@ -1,49 +1,6 @@
 require "active_support/notifications"
 
 module Nunes
-  # Extend and instrument. Simple class that makes it easy to instrument method
-  # timing using ActiveSupport::Notifications.
-  #
-  # The event name is the name of the method being instrumented and the event
-  # namespace is the name of the class the method is in.
-  #
-  # Examples
-  #
-  #   # To instrument an instance method, extend the module and instrument it.
-  #   class User
-  #     # Only need to do this once.
-  #     extend Nunes::Instrumentable
-  #
-  #     def something
-  #       # ...
-  #     end
-  #
-  #     instrument_method_time :something
-  #
-  #     # you can customize the event and namespace by providing the name option
-  #     instrument_method_time :something, {
-  #       name: "something.else.User",
-  #     }
-  #
-  #     # you can also add additional payload items
-  #     instrument_method_time :something, {
-  #       payload: {some: 'thing'},
-  #     }
-  #   end
-  #
-  #   # To instrument a class method, you need to extend the module on the
-  #   # singleton class and use the same to call the method.
-  #   class User
-  #     # Only need to do this once.
-  #     singleton_class.extend Nunes::Instrumentable
-  #
-  #     def self.something_class_level
-  #       # ...
-  #     end
-  #
-  #     singleton_class.instrument_method_time :someting_class_level
-  #   end
-  #
   module Instrumentable
     # Private
     MethodTimeEventName = "instrument_method_time.nunes".freeze
@@ -64,18 +21,17 @@ module Nunes
       instrumenter = options.fetch(:instrumenter) { ActiveSupport::Notifications }
 
       payload[:metric] = options.fetch(:name) {
-        "#{self.name}/#{method_name}"
-      }.to_s.underscore.gsub('/', '.')
+        if name.nil?
+          raise ArgumentError, "For class methods you must provide the full name of the metric."
+        else
+          "#{name}.#{method_name}"
+        end
+      }
 
       nunes_wrap_method(method_name, action) do |old_method_name, new_method_name|
         define_method(new_method_name) do |*args, &block|
           instrumenter.instrument(MethodTimeEventName, payload) {
-            result = send(old_method_name, *args, &block)
-
-            payload[:arguments] = args
-            payload[:result] = result
-
-            result
+            send(old_method_name, *args, &block)
           }
         end
       end

data/lib/nunes/subscriber.rb

@@ -32,38 +32,33 @@ module Nunes
     def call(name, start, ending, transaction_id, payload)
       # rails doesn't recommend instrumenting methods that start with bang
       # when in production
-      return if name.starts_with?(BANG)
+      return if name.start_with?(BANG)
 
       method_name = name.split('.').first
 
       if respond_to?(method_name)
         send(method_name, start, ending, transaction_id, payload)
-      else
-        $stderr.puts "#{self.class.name} did not respond to #{method_name} therefore it cannot instrument the event named #{name}."
       end
     end
 
     # Internal: Increment a metric for the client.
     #
     # metric - The String name of the metric to increment.
+    # value - The Integer value to increment by.
     #
     # Returns nothing.
-    def increment(metric)
-      if @adapter
-        @adapter.increment metric
-      end
+    def increment(metric, value = 1)
+      @adapter.increment metric, value
     end
 
     # Internal: Track the timing of a metric for the client.
     #
     # metric - The String name of the metric.
-    # duration_in_ms - The Integer duration of the event in milliseconds.
+    # value - The Integer duration of the event in milliseconds.
     #
     # Returns nothing.
-    def timing(metric, duration_in_ms)
-      if @adapter
-        @adapter.timing metric, duration_in_ms
-      end
+    def timing(metric, value)
+      @adapter.timing metric, value
     end
   end
 end

data/lib/nunes/subscribers/action_controller.rb

@@ -12,7 +12,7 @@ module Nunes
       end
 
       def process_action(start, ending, transaction_id, payload)
-        controller = payload[:controller].to_s.gsub('Controller', '').underscore
+        controller = payload[:controller]
         action = payload[:action]
         status = payload[:status]
         exception_info = payload[:exception]
@@ -28,19 +28,19 @@ module Nunes
 
         runtime = ((ending - start) * 1_000).round
 
-        timing "action_controller.runtime",      runtime      if runtime
-        timing "action_controller.view_runtime", view_runtime if view_runtime
-        timing "action_controller.db_runtime",   db_runtime   if db_runtime
+        timing "action_controller.runtime.total", runtime
+        timing "action_controller.runtime.view", view_runtime if view_runtime
+        timing "action_controller.runtime.db",   db_runtime   if db_runtime
 
         increment "action_controller.format.#{format}" if format
         increment "action_controller.status.#{status}" if status
 
         if controller && action
-          namespace = "action_controller.#{controller}.#{action}"
+          namespace = "action_controller.controller.#{controller}.#{action}"
 
-          timing "#{namespace}.runtime",      runtime      if runtime
-          timing "#{namespace}.view_runtime", view_runtime if view_runtime
-          timing "#{namespace}.db_runtime",   db_runtime   if db_runtime
+          timing "#{namespace}.runtime.total",      runtime
+          timing "#{namespace}.runtime.view", view_runtime if view_runtime
+          timing "#{namespace}.runtime.db",   db_runtime   if db_runtime
         end
 
         if exception_info

data/lib/nunes/subscribers/action_mailer.rb

@@ -16,7 +16,7 @@ module Nunes
         mailer = payload[:mailer]
 
         if mailer
-          timing "action_mailer.deliver.#{mailer.to_s.underscore}", runtime
+          timing "action_mailer.deliver.#{mailer}", runtime
         end
       end
 
@@ -25,7 +25,7 @@ module Nunes
         mailer = payload[:mailer]
 
         if mailer
-          timing "action_mailer.receive.#{mailer.to_s.underscore}", runtime
+          timing "action_mailer.receive.#{mailer}", runtime
         end
       end
     end

data/lib/nunes/subscribers/action_view.rb

@@ -12,20 +12,20 @@ module Nunes
       end
 
       def render_template(start, ending, transaction_id, payload)
-        instrument_identifier payload[:identifier], start, ending
+        instrument_identifier :template, payload[:identifier], start, ending
       end
 
       def render_partial(start, ending, transaction_id, payload)
-        instrument_identifier payload[:identifier], start, ending
+        instrument_identifier :partial, payload[:identifier], start, ending
       end
 
       private
 
       # Private: Sends timing information about identifier event.
-      def instrument_identifier(identifier, start, ending)
-        if identifier.present?
+      def instrument_identifier(kind, identifier, start, ending)
+        if identifier
           runtime = ((ending - start) * 1_000).round
-          timing identifier_to_metric(identifier), runtime
+          timing identifier_to_metric(kind, identifier), runtime
         end
       end
 
@@ -33,11 +33,10 @@ module Nunes
       # root from the full path.
       #
       # identifier - The String full path to the template or partial.
-      def identifier_to_metric(identifier)
-        rails_root = ::Rails.root.to_s + '/'
+      def identifier_to_metric(kind, identifier)
+        rails_root = ::Rails.root.to_s + File::SEPARATOR
         view_path = identifier.gsub(rails_root, '')
-        metric = view_path.gsub('/', '.')
-        "action_view.#{metric}"
+        "action_view.#{kind}.#{view_path}" if view_path
       end
     end
   end

data/lib/nunes/subscribers/active_support.rb

@@ -17,41 +17,41 @@ module Nunes
 
         case super_operation
         when Symbol
-          timing "active_support.cache_#{super_operation}", runtime
+          timing "active_support.cache.#{super_operation}", runtime
         else
-          timing "active_support.cache_read", runtime
+          timing "active_support.cache.read", runtime
         end
 
         hit = payload[:hit]
         unless hit.nil?
           hit_type = hit ? :hit : :miss
-          increment "active_support.cache_#{hit_type}"
+          increment "active_support.cache.#{hit_type}"
         end
       end
 
       def cache_generate(start, ending, transaction_id, payload)
         runtime = ((ending - start) * 1_000).round
-        timing "active_support.cache_generate", runtime
+        timing "active_support.cache.fetch_generate", runtime
       end
 
       def cache_fetch_hit(start, ending, transaction_id, payload)
         runtime = ((ending - start) * 1_000).round
-        timing "active_support.cache_fetch_hit", runtime
+        timing "active_support.cache.fetch_hit", runtime
       end
 
       def cache_write(start, ending, transaction_id, payload)
         runtime = ((ending - start) * 1_000).round
-        timing "active_support.cache_write", runtime
+        timing "active_support.cache.write", runtime
       end
 
       def cache_delete(start, ending, transaction_id, payload)
         runtime = ((ending - start) * 1_000).round
-        timing "active_support.cache_delete", runtime
+        timing "active_support.cache.delete", runtime
       end
 
       def cache_exist?(start, ending, transaction_id, payload)
         runtime = ((ending - start) * 1_000).round
-        timing "active_support.cache_exist", runtime
+        timing "active_support.cache.exist", runtime
       end
     end
   end

data/lib/nunes/subscribers/nunes.rb

@@ -15,9 +15,7 @@ module Nunes
         runtime = ((ending - start) * 1_000).round
         metric = payload[:metric]
 
-        if metric
-          timing "#{metric}", runtime
-        end
+        timing "#{metric}", runtime if metric
       end
     end
   end

data/lib/nunes/version.rb

@@ -1,3 +1,3 @@
 module Nunes
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/script/bench.rb

@@ -0,0 +1,48 @@
+require "benchmark"
+require "securerandom"
+require "active_support/notifications"
+require "bundler"
+Bundler.setup :default, :bench
+
+require_relative "../lib/nunes"
+
+adapter = Nunes::Adapter.wrap({})
+Nunes::Subscribers::ActionController.subscribe(adapter)
+
+require "rblineprof"
+$profile = lineprof(/./) do
+  puts Benchmark.realtime {
+    1_000.times do
+      ActiveSupport::Notifications.instrument("process_action.action_controller")
+    end
+  }
+end
+
+def show_file(file)
+  file = File.expand_path(file)
+  File.readlines(file).each_with_index do |line, num|
+    wall, cpu, calls = $profile[file][num+1]
+    if calls && calls > 0
+      printf "% 8.1fms + % 8.1fms (% 5d) | %s", cpu/1000.0, (wall-cpu)/1000.0, calls, line
+      # printf "% 8.1fms (% 5d) | %s", wall/1000.0, calls, line
+    else
+      printf "                                | %s", line
+      # printf "                   | %s", line
+    end
+  end
+end
+
+puts
+$profile.each do |file, data|
+  total, child, exclusive = data[0]
+  puts file
+  printf "  % 10.1fms in this file\n", exclusive/1000.0
+  printf "  % 10.1fms in this file + children\n", total/1000.0
+  printf "  % 10.1fms in children\n", child/1000.0
+
+  if file =~ /nunes\/lib/
+    show_file(file)
+  end
+
+  puts
+end

data/script/release

@@ -0,0 +1,42 @@
+#!/bin/sh
+#/ Usage: release
+#/
+#/ Tag the version in the repo and push the gem.
+#/
+
+set -e
+cd $(dirname "$0")/..
+
+[ "$1" = "--help" -o "$1" = "-h" -o "$1" = "help" ] && {
+    grep '^#/' <"$0"| cut -c4-
+    exit 0
+}
+
+gem_name=nunes
+
+# Build a new gem archive.
+rm -rf $gem_name-*.gem
+gem build -q $gem_name.gemspec
+
+# Make sure we're on the master branch.
+(git branch | grep -q '* master') || {
+  echo "Only release from the master branch."
+  exit 1
+}
+
+# Figure out what version we're releasing.
+tag=v`ls $gem_name-*.gem | sed "s/^$gem_name-\(.*\)\.gem$/\1/"`
+
+echo "Releasing $tag"
+
+# Make sure we haven't released this version before.
+git fetch -t origin
+
+(git tag -l | grep -q "$tag") && {
+  echo "Whoops, there's already a '${tag}' tag."
+  exit 1
+}
+
+# Tag it and bag it.
+gem push $gem_name-*.gem && git tag "$tag" &&
+  git push origin master && git push origin "$tag"

data/test/adapter_test.rb

@@ -1,6 +1,11 @@
 require "helper"
+require "minitest/mock"
 
 class AdapterTest < ActiveSupport::TestCase
+  def separator
+    Nunes::Adapter::Separator
+  end
+
   test "wrap for statsd" do
     client_with_gauge_and_timing = Class.new do
       def increment(*args); end
@@ -9,7 +14,7 @@ class AdapterTest < ActiveSupport::TestCase
     end.new
 
     adapter = Nunes::Adapter.wrap(client_with_gauge_and_timing)
-    assert_instance_of Nunes::Adapters::Default, adapter
+    assert_instance_of Nunes::Adapter, adapter
   end
 
   test "wrap for instrumental" do
@@ -37,4 +42,75 @@ class AdapterTest < ActiveSupport::TestCase
   test "wrap with nil" do
     assert_raises(ArgumentError) { Nunes::Adapter.wrap(nil) }
   end
+
+  test "wrap with straight up gibberish yo" do
+    assert_raises(ArgumentError) { Nunes::Adapter.wrap(Object.new) }
+  end
+
+  test "passes increment along" do
+    mock = MiniTest::Mock.new
+    mock.expect :increment, nil, ["single", 1]
+    mock.expect :increment, nil, ["double", 2]
+
+    client = Nunes::Adapter.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::Adapter.new(mock)
+    client.timing("foo", 23)
+
+    mock.verify
+  end
+
+  test "prepare leaves good metrics alone" do
+    adapter = Nunes::Adapter.new(nil)
+
+    [
+      "foo",
+      "foo1234",
+      "foo-bar",
+      "foo_bar",
+      "Foo",
+      "FooBar",
+      "FOOBAR",
+      "foo#{separator}bar",
+      "foo#{separator}bar_baz",
+      "foo#{separator}bar_baz-wick",
+      "Foo#{separator}1234",
+      "Foo#{separator}Bar1234",
+    ].each do |expected|
+      assert_equal expected, adapter.prepare(expected)
+    end
+  end
+
+  test "prepare with bad metric names" do
+    adapter = Nunes::Adapter.new(nil)
+
+    {
+      "#{separator}foo"                         => "foo",
+      "foo#{separator}"                         => "foo",
+      "foo@bar"                                 => "foo#{separator}bar",
+      "foo@$%^*^&bar"                           => "foo#{separator}bar",
+      "foo#{separator}#{separator}bar"          => "foo#{separator}bar",
+      "app/views/posts"                         => "app#{separator}views#{separator}posts",
+      "Admin::PostsController#{separator}index" => "Admin#{separator}PostsController#{separator}index",
+    }.each do |metric, expected|
+      assert_equal expected, adapter.prepare(metric)
+    end
+  end
+
+  test "prepare does not modify original metric" do
+    adapter = Nunes::Adapter.new(nil)
+    original = "app/views/posts"
+    result = adapter.prepare("original")
+
+    assert_equal "app/views/posts", original
+  end
 end

data/test/cache_instrumentation_test.rb

@@ -27,8 +27,8 @@ class CacheInstrumentationTest < ActiveSupport::TestCase
   test "cache_read miss" do
     cache.read('foo')
 
-    assert_timer "active_support.cache_read"
-    assert_counter "active_support.cache_miss"
+    assert_timer "active_support.cache.read"
+    assert_counter "active_support.cache.miss"
   end
 
   test "cache_read hit" do
@@ -36,13 +36,13 @@ class CacheInstrumentationTest < ActiveSupport::TestCase
     adapter.clear
     cache.read('foo')
 
-    assert_timer "active_support.cache_read"
-    assert_counter "active_support.cache_hit"
+    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"
+    assert_timer "active_support.cache.fetch_generate"
   end
 
   test "cache_fetch with hit" do
@@ -50,30 +50,30 @@ class CacheInstrumentationTest < ActiveSupport::TestCase
     adapter.clear
     cache.fetch('foo') { |key| :never_gets_here }
 
-    assert_timer "active_support.cache_fetch"
-    assert_timer "active_support.cache_fetch_hit"
+    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"
+    assert_timer "active_support.cache.fetch"
+    assert_timer "active_support.cache.fetch_generate"
+    assert_timer "active_support.cache.write"
   end
 
   test "cache_write" do
     cache.write('foo', 'bar')
-    assert_timer "active_support.cache_write"
+    assert_timer "active_support.cache.write"
   end
 
   test "cache_delete" do
     cache.delete('foo')
-    assert_timer "active_support.cache_delete"
+    assert_timer "active_support.cache.delete"
   end
 
   test "cache_exist?" do
     cache.exist?('foo')
-    assert_timer "active_support.cache_exist"
+    assert_timer "active_support.cache.exist"
   end
 end

data/test/controller_instrumentation_test.rb

@@ -22,11 +22,11 @@ class ControllerInstrumentationTest < ActionController::TestCase
     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.runtime.total"
+    assert_timer "action_controller.runtime.view"
 
-    assert_timer "action_controller.posts.index.runtime"
-    assert_timer "action_controller.posts.index.view_runtime"
+    assert_timer "action_controller.controller.PostsController.index.runtime.total"
+    assert_timer "action_controller.controller.PostsController.index.runtime.view"
   end
 
   test "send_data" do
@@ -36,11 +36,11 @@ class ControllerInstrumentationTest < ActionController::TestCase
 
     assert_counter "action_controller.status.200"
 
-    assert_timer "action_controller.runtime"
-    assert_timer "action_controller.view_runtime"
+    assert_timer "action_controller.runtime.total"
+    assert_timer "action_controller.runtime.view"
 
-    assert_timer "action_controller.posts.some_data.runtime"
-    assert_timer "action_controller.posts.some_data.view_runtime"
+    assert_timer "action_controller.controller.PostsController.some_data.runtime.total"
+    assert_timer "action_controller.controller.PostsController.some_data.runtime.view"
   end
 
   test "send_file" do
@@ -50,11 +50,11 @@ class ControllerInstrumentationTest < ActionController::TestCase
 
     assert_counter"action_controller.status.200"
 
-    assert_timer "action_controller.runtime"
-    assert_timer "action_controller.posts.some_file.runtime"
+    assert_timer "action_controller.runtime.total"
+    assert_timer "action_controller.controller.PostsController.some_file.runtime.total"
 
-    assert ! adapter.timer?("action_controller.view_runtime")
-    assert ! adapter.timer?("action_controller.posts.some_file.view_runtime")
+    assert ! adapter.timer?("action_controller.runtime.view")
+    assert ! adapter.timer?("action_controller.controller.PostsController.some_file.runtime.view")
   end
 
   test "redirect_to" do
@@ -64,11 +64,11 @@ class ControllerInstrumentationTest < ActionController::TestCase
 
     assert_counter "action_controller.status.302"
 
-    assert_timer "action_controller.runtime"
-    assert_timer "action_controller.posts.some_redirect.runtime"
+    assert_timer "action_controller.runtime.total"
+    assert_timer "action_controller.controller.PostsController.some_redirect.runtime.total"
 
-    assert_no_timer "action_controller.view_runtime"
-    assert_no_timer "action_controller.posts.some_redirect.view_runtime"
+    assert_no_timer "action_controller.runtime.view"
+    assert_no_timer "action_controller.controller.PostsController.some_redirect.runtime.view"
   end
 
   test "action with exception" do
@@ -79,10 +79,10 @@ class ControllerInstrumentationTest < ActionController::TestCase
     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_timer "action_controller.runtime.total"
+    assert_timer "action_controller.controller.PostsController.some_boom.runtime.total"
 
-    assert_no_timer "action_controller.view_runtime"
-    assert_no_timer "action_controller.posts.some_boom.view_runtime"
+    assert_no_timer "action_controller.runtime.view"
+    assert_no_timer "action_controller.controller.PostsController.some_boom.runtime.view"
   end
 end

data/test/instrumentable_test.rb

@@ -18,6 +18,14 @@ class InstrumentationTest < ActiveSupport::TestCase
     @thing_class = Class.new {
       extend Nunes::Instrumentable
 
+      class << self
+        extend Nunes::Instrumentable
+
+        def find(*args)
+          :nope
+        end
+      end
+
       def self.name
         'Thing'
       end
@@ -50,12 +58,31 @@ class InstrumentationTest < ActiveSupport::TestCase
     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_equal "Thing.yo", event.payload[:metric]
+    assert_in_delta 0, event.duration, 0.1
+
+    assert_timer "Thing.yo"
+  end
+
+  test "instrument_method_time for class method without full metric name" do
+    # I'd really like to not do this, but I don't have a name for the class
+    # which makes it hard to automatically set the name. If anyone has a fix,
+    # let me know.
+    assert_raises ArgumentError do
+      thing_class.singleton_class.instrument_method_time :find
+    end
+  end
+
+  test "instrument_method_time for class method" do
+    thing_class.singleton_class.instrument_method_time :find, "Thing.find"
+
+    event = slurp_events { thing_class.find(1) }.last
+
+    assert_not_nil event, "No events were found."
+    assert_equal "Thing.find", event.payload[:metric]
     assert_in_delta 0, event.duration, 0.1
 
-    assert_timer "thing.yo"
+    assert_timer "Thing.find"
   end
 
   test "instrument_method_time with custom name in hash" do
@@ -64,9 +91,9 @@ class InstrumentationTest < ActiveSupport::TestCase
     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_equal "Thingy.yohoho", event.payload[:metric]
 
-    assert_timer "thingy.yohoho"
+    assert_timer "Thingy.yohoho"
   end
 
   test "instrument_method_time with custom name as string" do
@@ -75,9 +102,9 @@ class InstrumentationTest < ActiveSupport::TestCase
     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_equal "Thingy.yohoho", event.payload[:metric]
 
-    assert_timer "thingy.yohoho"
+    assert_timer "Thingy.yohoho"
   end
 
   test "instrument_method_time with custom payload" do
@@ -88,7 +115,7 @@ class InstrumentationTest < ActiveSupport::TestCase
     assert_not_nil event, "No events were found."
     assert_equal "loadin", event.payload[:pay]
 
-    assert_timer "thing.yo"
+    assert_timer "Thing.yo"
   end
 
   def slurp_events(&block)

data/test/mailer_instrumentation_test.rb

@@ -16,11 +16,11 @@ class MailerInstrumentationTest < ActionMailer::TestCase
 
   test "deliver" do
     PostMailer.created.deliver
-    assert_timer "action_mailer.deliver.post_mailer"
+    assert_timer "action_mailer.deliver.PostMailer"
   end
 
   test "receive" do
     PostMailer.receive PostMailer.created
-    assert_timer "action_mailer.receive.post_mailer"
+    assert_timer "action_mailer.receive.PostMailer"
   end
 end

data/test/namespaced_controller_instrumentation_test.rb

@@ -0,0 +1,25 @@
+require "helper"
+
+class NamespacedControllerInstrumentationTest < ActionController::TestCase
+  tests Admin::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_timer "action_controller.controller.Admin.PostsController.index.runtime.total"
+    assert_timer "action_controller.controller.Admin.PostsController.index.runtime.view"
+  end
+end

data/test/rails_app/app/controllers/admin/posts_controller.rb

@@ -0,0 +1,11 @@
+class Admin::PostsController < ApplicationController
+  # Use fake post for controller as I don't want active record to mingle here.
+  Post = Struct.new(:title)
+
+  def index
+    @posts = [
+      Post.new('First'),
+      Post.new('Second'),
+    ]
+  end
+end

data/test/rails_app/app/views/admin/posts/index.html.erb

@@ -0,0 +1,5 @@
+<h1>Admin Posts</h1>
+
+<% @posts.each do |post| %>
+  <%= render 'posts/post', post: post %>
+<% end %>

data/test/rails_app/config/routes.rb

@@ -1,4 +1,8 @@
 RailsApp::Application.routes.draw do
+  namespace :admin do
+    resources :posts, only: :index
+  end
+
   resources :posts, only: :index
 
   get "/some-data",     to: "posts#some_data"

data/test/view_instrumentation_test.rb

@@ -18,13 +18,13 @@ class ViewInstrumentationTest < ActionController::TestCase
     get :index
 
     assert_response :success
-    assert_timer "action_view.app.views.posts.index.html.erb"
+    assert_timer "action_view.template.app.views.posts.index.html.erb"
   end
 
   test "render_partial" do
     get :index
 
     assert_response :success
-    assert_timer "action_view.app.views.posts._post.html.erb"
+    assert_timer "action_view.partial.app.views.posts._post.html.erb"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nunes
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-18 00:00:00.000000000 Z
+date: 2013-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -36,12 +36,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- Changelog.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - lib/nunes.rb
 - lib/nunes/adapter.rb
-- lib/nunes/adapters/default.rb
 - lib/nunes/adapters/memory.rb
 - lib/nunes/adapters/timing_aliased.rb
 - lib/nunes/instrumentable.rb
@@ -54,11 +54,12 @@ files:
 - lib/nunes/subscribers/nunes.rb
 - lib/nunes/version.rb
 - nunes.gemspec
+- script/bench.rb
 - script/bootstrap
+- script/release
 - script/test
 - script/watch
 - test/adapter_test.rb
-- test/adapters/default_test.rb
 - test/adapters/timing_aliased_test.rb
 - test/cache_instrumentation_test.rb
 - test/controller_instrumentation_test.rb
@@ -67,12 +68,14 @@ files:
 - test/instrumentable_test.rb
 - test/mailer_instrumentation_test.rb
 - test/model_instrumentation_test.rb
+- test/namespaced_controller_instrumentation_test.rb
 - test/nunes_test.rb
 - test/rails_app/.gitignore
 - test/rails_app/Rakefile
 - test/rails_app/app/assets/images/rails.png
 - test/rails_app/app/assets/javascripts/application.js
 - test/rails_app/app/assets/stylesheets/application.css
+- test/rails_app/app/controllers/admin/posts_controller.rb
 - test/rails_app/app/controllers/application_controller.rb
 - test/rails_app/app/controllers/posts_controller.rb
 - test/rails_app/app/helpers/application_helper.rb
@@ -80,6 +83,7 @@ files:
 - test/rails_app/app/mailers/post_mailer.rb
 - test/rails_app/app/models/.gitkeep
 - test/rails_app/app/models/post.rb
+- test/rails_app/app/views/admin/posts/index.html.erb
 - test/rails_app/app/views/layouts/application.html.erb
 - test/rails_app/app/views/post_mailer/created.text.erb
 - test/rails_app/app/views/posts/_post.html.erb
@@ -144,7 +148,6 @@ specification_version: 3
 summary: The friendly gem that instruments everything for you, like I would if I could.
 test_files:
 - test/adapter_test.rb
-- test/adapters/default_test.rb
 - test/adapters/timing_aliased_test.rb
 - test/cache_instrumentation_test.rb
 - test/controller_instrumentation_test.rb
@@ -153,12 +156,14 @@ test_files:
 - test/instrumentable_test.rb
 - test/mailer_instrumentation_test.rb
 - test/model_instrumentation_test.rb
+- test/namespaced_controller_instrumentation_test.rb
 - test/nunes_test.rb
 - test/rails_app/.gitignore
 - test/rails_app/Rakefile
 - test/rails_app/app/assets/images/rails.png
 - test/rails_app/app/assets/javascripts/application.js
 - test/rails_app/app/assets/stylesheets/application.css
+- test/rails_app/app/controllers/admin/posts_controller.rb
 - test/rails_app/app/controllers/application_controller.rb
 - test/rails_app/app/controllers/posts_controller.rb
 - test/rails_app/app/helpers/application_helper.rb
@@ -166,6 +171,7 @@ test_files:
 - test/rails_app/app/mailers/post_mailer.rb
 - test/rails_app/app/models/.gitkeep
 - test/rails_app/app/models/post.rb
+- test/rails_app/app/views/admin/posts/index.html.erb
 - test/rails_app/app/views/layouts/application.html.erb
 - test/rails_app/app/views/post_mailer/created.text.erb
 - test/rails_app/app/views/posts/_post.html.erb

data/lib/nunes/adapters/default.rb

@@ -1,10 +0,0 @@
-require "nunes/adapter"
-
-module Nunes
-  module Adapters
-    # Internal: Default is the assumed interface, so we don't need to override
-    # anything. This should never need to be used directly by a user of the gem.
-    class Default < ::Nunes::Adapter
-    end
-  end
-end

data/test/adapters/default_test.rb

@@ -1,26 +0,0 @@
-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