unicorn_metrics 0.1.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MzM4NmFhYWM4ZjU5YjAxMGE0NjA5YWQ0ZTUzMTEwNjI0OGE5YmRmOQ==
+  data.tar.gz: !binary |-
+    MmYxZDljYTIyZTRkZjAyZjkyYTMzMGZhNzc2ZmUxOTA4NWI3MzM5OA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZjZiNzRjODE2MmIzNzY0YmI1MWRjNjdkMjMwNGUzOWFmY2NlZTIyMGI3MTM1
+    MTA3ODU4MTM5ZTZjYTY4OTMzNThiYzFlYzc5MzZmMmU3Mzg2ZWQwMzhhNGQx
+    YTY3ZDE2MGFmNDJhYmU2ZDZjYmI1NTQyZTFlYzU2NTFkYTc1NDU=
+  data.tar.gz: !binary |-
+    ZjhiMDNkZjczNjJmNzQ2Y2JmMDIwYTliODk1MWZhNTU5MTE5ZGVhMDFlMzBk
+    MzZmZDc0MTE0YzNkNGQ2ZWI3M2FjYmU5YWNmNmVhODkwMDNlOTA5MjVjZWUx
+    MTljNTJlOGM2MGY1NzEyNDg3YTlhOTYxYTg4Mzk1NjU1ODRiZTc=

data/lib/unicorn_metrics/counter.rb

@@ -0,0 +1,41 @@
+# UnicornMetrics::Counter is an atomic counter that conveniently wraps the Raindrops::Struct
+#
+class UnicornMetrics::Counter
+  extend Forwardable
+
+  attr_reader :name
+
+  class Stats < Raindrops::Struct.new(:value) ; end
+
+  # Delegate getter and setter to @stats
+  def_instance_delegator :@stats, :value
+
+  # Provide #increment and #decrement by delegating to @stats
+  def_instance_delegator :@stats, :incr_value, :increment
+  def_instance_delegator :@stats, :decr_value, :decrement
+
+  # @param name [String] user-defined name
+  def initialize(name)
+    @name  = name
+    @stats = Stats.new
+  end
+
+  # Reset the counter
+  def reset
+    @stats.value = 0
+  end
+
+  def type
+    "counter"
+  end
+
+  # @return [Hash] JSON representation of the object
+  def as_json(*)
+    {
+      name => {
+        "type"  => type,
+        "value" => value
+      }
+    }
+  end
+end

data/lib/unicorn_metrics/default_http_metrics.rb

@@ -0,0 +1,16 @@
+module UnicornMetrics::DefaultHttpMetrics
+  def register_default_http_counters
+    [
+      ["responses.2xx", /[2]\d{2}/], ["responses.3xx", /[3]\d{2}/],
+      ["responses.4xx", /[4]\d{2}/], ["responses.5xx", /[5]\d{2}/]
+    ].each { |c| register(:response_counter, *c) }
+  end
+
+  def register_default_http_timers
+    [
+      ['requests.GET', 'GET'], ['requests.POST', 'POST'],
+      ['requests.DELETE', 'DELETE'], ['requests.HEAD', 'HEAD'],
+      ['requests.PUT', 'PUT']
+    ].each { |c| register(:request_timer, *c) }
+  end
+end

data/lib/unicorn_metrics/middleware.rb

@@ -0,0 +1,116 @@
+# UnicornMetrics::Middleware extends the existing Raindrops::Middleware class
+#
+require 'unicorn_metrics' unless defined?(UnicornMetrics)
+require 'raindrops'
+require 'benchmark'
+
+class UnicornMetrics::Middleware < Raindrops::Middleware
+
+  # @param opts [Hash] options hash
+  # @option opts [String] :metrics the HTTP endpoint that exposes the application metrics
+  def initialize(app, opts = {})
+    @registry     = UnicornMetrics::Registry
+    @metrics_path = opts[:metrics] || "/metrics"
+    super
+  end
+
+  def call(env)
+    return metrics_response if env['PATH_INFO'] == @metrics_path
+
+    response = nil
+    time = Benchmark.realtime do
+      response = super
+      #=> [  status, headers, <#Raindrops::Middleware::Proxy> ]
+      # Proxy is a wrapper around the response body
+    end
+    collect_http_metrics(env, response, time) if UnicornMetrics.http_metrics?
+    response
+  end
+
+  private
+  def metrics_response
+    body = @registry.as_json.merge(raindrops).to_json
+
+    headers = {
+      "Content-Type" => "application/json",
+      "Content-Length" => body.size.to_s,
+    }
+    [ 200, headers, [ body ] ]
+  end
+
+  def collect_http_metrics(env, response, elapsed_time)
+    method, path = env['REQUEST_METHOD'], env['PATH_INFO']
+    status = response[0]
+
+    UnicornMetrics::ResponseCounter.notify(status, path)
+    UnicornMetrics::RequestTimer.notify(method, path, elapsed_time)
+  end
+
+  # Provide Raindrops::Middleware statistics in the metrics JSON response
+  # `@stats` is defined in the Raindrops::Middleware class
+
+  # * calling - the number of application dispatchers on your machine
+  # * writing - the number of clients being written to on your machine
+  def raindrops
+    {
+      "raindrops.calling" => {
+        "type" => "gauge",
+        "value" => @stats.calling
+      },
+      "raindrops.writing" => {
+        "type" => "gauge",
+        "value" => @stats.writing
+      }
+    }.merge(total_listener_stats)
+  end
+
+  # Supporting additional stats collected by Raindrops for Linux platforms
+  # `@tcp` and `@unix` are defined in Raindrops::Middleware
+  def total_listener_stats(listeners={})
+    if defined?(Raindrops::Linux.tcp_listener_stats)
+      listeners.merge!(raindrops_tcp_listener_stats) if @tcp
+      listeners.merge!(raindrops_unix_listener_stats) if @unix
+    end
+    listeners
+  end
+
+  def raindrops_tcp_listener_stats
+    hash = {
+      "raindrops.tcp.active" => { type: :gauge, value: 0 },
+      "raindrops.tcp.queued" => { type: :gauge, value: 0 }
+    }
+    Raindrops::Linux.tcp_listener_stats(@tcp).each do |_, stats|
+      hash["raindrops.tcp.active"][:value] += stats.active.to_i
+      hash["raindrops.tcp.queued"][:value] += stats.queued.to_i
+    end
+    hash
+  end
+
+  def raindrops_unix_listener_stats
+    hash = {
+      "raindrops.unix.active" => { type: :gauge, value: 0 },
+      "raindrops.unix.queued" => { type: :gauge, value: 0 }
+    }
+    Raindrops::Linux.unix_listener_stats(@unix).each do |_, stats|
+      hash["raindrops.unix.active"][:value] += stats.active.to_i
+      hash["raindrops.unix.queued"][:value] += stats.queued.to_i
+    end
+    hash
+  end
+
+  # NOTE: The 'total' is being used in favor of returning stats for \
+  # each listening address, which was the default in Raindrops
+  def listener_stats(listeners={})
+    if defined?(Raindrops::Linux.tcp_listener_stats)
+      Raindrops::Linux.tcp_listener_stats(@tcp).each do |addr,stats|
+        listeners["raindrops.#{addr}.active"] = "#{stats.active}"
+        listeners["raindrops.#{addr}.queued"] = "#{stats.queued}"
+      end if @tcp
+      Raindrops::Linux.unix_listener_stats(@unix).each do |addr,stats|
+        listeners["raindrops.#{addr}.active"] = "#{stats.active}"
+        listeners["raindrops.#{addr}.queued"] = "#{stats.queued}"
+      end if @unix
+    end
+    listeners
+  end
+end

data/lib/unicorn_metrics/registry.rb

@@ -0,0 +1,75 @@
+# Borrowing nomenclature from http://metrics.codahale.com/
+#
+# To support a cleaner interface, the UnicornMetrics module delegates to the Registry
+# for supported methods. Methods should not be called directly on this module
+
+# UnicornMetrics::Registry is a container for Metrics
+# @private
+module UnicornMetrics::Registry
+
+  # Map metrics types to class names
+  METRIC_TYPES = {
+    :counter          => 'Counter',
+    :timer            => 'Timer',
+    :response_counter => 'ResponseCounter',
+    :request_counter  => 'RequestCounter',
+    :request_timer    => 'RequestTimer'
+  }
+
+  class << self
+
+    # Return a hash of metrics that have been defined
+    #
+    # @return [Hash] a metric name to metric object
+    def metrics
+      @metrics ||= {}
+    end
+
+    # Register a new metric. Arguments are optional. See metric class definitions.
+    #
+    # @param type [Symbol] underscored metric name
+    # @param name [String] string representing the metric name
+    # @return [Counter, Timer, ResponseCounter, RequestCounter, RequestTimer]
+    def register(type, name, *args)
+      type          = METRIC_TYPES.fetch(type) { raise "Invalid type: #{type}" }
+      validate_name!(name)
+      metric        = UnicornMetrics.const_get(type).new(name,*args)
+      metrics[name] = metric
+      define_getter(name)
+
+      metric
+    end
+
+    # @return [Hash] default JSON representation of metrics
+    def as_json(*)
+      metrics.inject({}) do |hash, (name, metric)|
+        hash.merge(metric.as_json)
+      end
+    end
+
+    private
+    # Convenience methods to return the stored metrics.
+    # Allows the use of names with spaces, dots, and dashes, which are \
+    # replaced by an underscore:
+    #
+    # def UnicornMetrics::Registry.stat_name
+    #   metrics.fetch('stat_name')
+    # end
+    #
+    def define_getter(name)
+      define_singleton_method(format_name(name)) { metrics.fetch(name) }
+    end
+
+    # Replace non-word characters with '_'
+    def format_name(name)
+      name.gsub(/\W/, '_')
+    end
+
+    # @raise [ArgumentError] if the metric name is in use
+    def validate_name!(name)
+      if metrics.fetch(name,false)
+        raise ArgumentError, "The name, '#{name}', is in use."
+      end
+    end
+  end
+end

data/lib/unicorn_metrics/request_counter.rb

@@ -0,0 +1,42 @@
+# Counter defined to keep count of method types of http requests
+# Requires the UnicornMetrics::Middleware
+
+class UnicornMetrics::RequestCounter < UnicornMetrics::Counter
+  attr_reader :path, :method_name
+
+  METHOD_COUNTERS = []
+
+  # @param name [String] user-defined name
+  # @param method_name [String] name of the HTTP method
+  # @param path [Regex] optional regex that is used to match to a specific URI
+  def initialize(name, method_name, path=nil)
+    @path        = path
+    @method_name = method_name.to_s.upcase
+    METHOD_COUNTERS << self
+    super(name)
+  end
+
+  # @return [Array<UnicornMetrics::RequestCounter>]
+  def self.counters ; METHOD_COUNTERS ; end
+
+  # @param meth_val [String] is the HTTP method of the request
+  # @param path [String] is the URI of the request
+  def self.notify(meth_val, path)
+    counters.each { |c| c.increment if c.path_method_match?(meth_val, path) }
+  end
+
+  # @param (see #notify)
+  # @return [Boolean]
+  def path_method_match?(meth_val, path_val)
+    path_matches?(path_val) && method_matches?(meth_val)
+  end
+
+  private
+  def path_matches?(val)
+    !!(path =~ val) || path.nil?
+  end
+
+  def method_matches?(val)
+    method_name.upcase == val.to_s
+  end
+end

data/lib/unicorn_metrics/request_timer.rb

@@ -0,0 +1,43 @@
+# Timer defined to keep track of total elapsed request time
+# Requires the UnicornMetrics::Middleware
+
+class UnicornMetrics::RequestTimer < UnicornMetrics::Timer
+  attr_reader :path, :method_name
+
+  REQUEST_TIMERS = []
+
+  # @param name [String] user-defined name
+  # @param method_name [String] name of the HTTP method
+  # @param path [Regex] optional regex that is used to match to a specific URI
+  def initialize(name, method_name, path=nil)
+    @path        = path
+    @method_name = method_name.to_s
+    REQUEST_TIMERS << self
+    super(name)
+  end
+
+  # @return [Array<UnicornMetrics::RequestTimer>]
+  def self.timers ; REQUEST_TIMERS ; end
+
+  # @param meth_val [String] is the HTTP method of the request
+  # @param path [String] is the URI of the request
+  def self.notify(meth_val, path, elapsed_time)
+    timers.each { |c| c.tick(elapsed_time) if c.path_method_match?(meth_val, path) }
+  end
+
+
+  # @param (see #notify)
+  # @return [Boolean]
+  def path_method_match?(meth_val, path_val)
+    path_matches?(path_val) && method_matches?(meth_val)
+  end
+
+  private
+  def path_matches?(val)
+    !!(path =~ val) || path.nil?
+  end
+
+  def method_matches?(val)
+    method_name.upcase == val.to_s
+  end
+end

data/lib/unicorn_metrics/response_counter.rb

@@ -0,0 +1,43 @@
+# Counter defined to keep count of status codes of http responses
+# Requires the UnicornMetrics::Middleware
+
+class UnicornMetrics::ResponseCounter < UnicornMetrics::Counter
+  attr_reader :path, :status_code
+
+  STATUS_COUNTERS = []
+
+  # @param name [String] user-defined name
+  # @param status_code [Regex] the HTTP status code (e.g., `/[2]\d{2}/`)
+  # @param path [Regex] optional regex that is used to match to a specific URI
+  def initialize(name, status_code, path=nil)
+    @path        = path
+    @status_code = status_code
+    STATUS_COUNTERS << self
+    super(name)
+  end
+
+  # @return [Array<UnicornMetrics::ResponseCounter>]
+  def self.counters ; STATUS_COUNTERS ; end
+
+
+  # @param status [String] is the HTTP status code of the request
+  # @param path [String] is the URI of the request
+  def self.notify(status, path)
+    counters.each { |c| c.increment if c.path_status_match?(status, path) }
+  end
+
+  # @param (see #notify)
+  # @return [Boolean]
+  def path_status_match?(status,path)
+    status_matches?(status) && path_matches?(path)
+  end
+
+  private
+  def path_matches?(val)
+    path.nil? || !!(path =~ val)
+  end
+
+  def status_matches?(val)
+    !!(status_code =~ val.to_s)
+  end
+end

data/lib/unicorn_metrics/timer.rb

@@ -0,0 +1,57 @@
+# UnicornMetrics::Timer keeps track of total time and the count of 'ticks'
+# A simple rate of average of ticks over time elapsed can be calculated this way.
+# For more advanced metrics (e.g., 1/5/15min moving averages) this data should be reported to an intelligent metric store (i.e. Graphite)
+#
+class UnicornMetrics::Timer
+  extend Forwardable
+
+  attr_reader :name
+
+  # The Raindrops::Struct can only hold unsigned long ints (0 -> 4,294,967,295)
+  # Since we usually care about ms in a web application, \
+  # let's store 3 significant digits after the decimal
+  EXPONENT = -3
+
+  class Stats < Raindrops::Struct.new(:count, :mantissa) ; end
+
+  def_instance_delegators :@stats, :mantissa, :count
+
+  # @param name [String] user-defined name
+  def initialize(name)
+    @name  = name
+    @stats = Stats.new
+  end
+
+  def type
+    "timer"
+  end
+
+  # @param elapsed_time [Numeric] in seconds
+  def tick(elapsed_time)
+    elapsed_time = (elapsed_time * 10**-EXPONENT).to_i
+
+    @stats.mantissa = mantissa + elapsed_time
+    @stats.incr_count
+  end
+
+  # Reset the timer
+  def reset
+    @stats.mantissa = 0 and @stats.count = 0
+  end
+
+  # @return [Numeric] total elapsed time
+  def sum
+    (mantissa * 10**EXPONENT).to_f.round(-EXPONENT)
+  end
+
+  # @return [Hash] JSON representation of the object
+  def as_json(*)
+    {
+      name => {
+        "type"  => type,
+        "sum"   => sum,
+        "count" => count
+      }
+    }
+  end
+end

data/lib/unicorn_metrics/version.rb

@@ -0,0 +1,3 @@
+module UnicornMetrics
+  VERSION = "0.1.1"
+end

data/lib/unicorn_metrics.rb

@@ -0,0 +1,62 @@
+module UnicornMetrics
+  class << self
+
+    # Returns the UnicornMetrics::Registry object
+    #
+    # @return [UnicornMetrics::Registry]
+    def registry
+      UnicornMetrics::Registry
+    end
+
+    # Make this class 'configurable'
+    #
+    # @yieldparam self [UnicornMetrics]
+    def configure
+      yield self
+    end
+
+    # Enable/disable HTTP metrics. Includes defaults
+    #
+    # @param boolean [Boolean] to enable or disable default HTTP metrics
+    def http_metrics=(boolean=false)
+      return if @_assigned
+
+      if @http_metrics = boolean
+        registry.extend(UnicornMetrics::DefaultHttpMetrics)
+        registry.register_default_http_counters
+        registry.register_default_http_timers
+      end
+      @_assigned = true
+    end
+
+    # Used by the middleware to determine whether any HTTP metrics have been defined
+    #
+    # @return [Boolean] if HTTP metrics have been defined
+    def http_metrics? ; @http_metrics ; end
+
+    private
+    # Delegate methods to UnicornMetrics::Registry
+    #
+    # http://robots.thoughtbot.com/post/28335346416/always-define-respond-to-missing-when-overriding
+    def respond_to_missing?(method_name, include_private=false)
+      registry.respond_to?(method_name, include_private)
+    end
+
+    def method_missing(method_name, *args, &block)
+      return super unless registry.respond_to?(method_name)
+      registry.send(method_name, *args, &block)
+    end
+  end
+end
+
+require 'raindrops'
+require 'unicorn_metrics/registry'
+require 'unicorn_metrics/version'
+require 'unicorn_metrics/counter'
+require 'unicorn_metrics/timer'
+require 'unicorn_metrics/default_http_metrics'
+require 'unicorn_metrics/request_counter'
+require 'unicorn_metrics/request_timer'
+require 'unicorn_metrics/response_counter'
+require 'forwardable'
+

data/test/test_counter.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+
+describe UnicornMetrics::Counter do
+  before do
+    @counter = UnicornMetrics::Counter.new("test_counter")
+    @counter.reset
+  end
+
+  describe "#type" do
+    it "returns 'counter'" do
+      @counter.type.must_equal 'counter'
+    end
+  end
+
+  describe "#value" do
+    it "returns the internal count" do
+      @counter.value.must_equal 0
+    end
+  end
+
+  describe "#increment" do
+    it "increments the counter value" do
+      5.times { @counter.increment }
+      @counter.value.must_equal 5
+    end
+  end
+
+  describe "#decrement" do
+    it "decrements the counter value" do
+      5.times { @counter.increment }
+      5.times { @counter.decrement }
+      @counter.value.must_equal 0
+    end
+  end
+
+  describe "#reset" do
+    it "resets the counter value" do
+      5.times { @counter.increment }
+      @counter.reset
+      @counter.value.must_equal 0
+    end
+  end
+
+  describe "#as_json" do
+    it "returns the JSON representation of the object as a hash" do
+      hash = {
+        @counter.name => {
+          "type"  => @counter.type,
+          "value" => @counter.value
+        }
+      }
+
+      @counter.as_json.must_equal hash
+    end
+  end
+
+  # REFACTOR: This test is very slow
+  describe "forking" do
+    it "can be shared across processes" do
+      2.times { fork { @counter.increment ; exit } }
+      Process.waitall
+      @counter.value.must_equal 2
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'unicorn_metrics'
+
+alias :context :describe

data/test/test_middleware.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+require 'unicorn_metrics/middleware'
+require 'json'
+
+# Stubbing Raindrops::Linux to support testing listener statistics
+# See Raindrops::Middleware and Raindrops::Linux
+module Raindrops::Linux
+  Stats = Struct.new(:active, :queued)
+  def self.tcp_listener_stats(*)  ; [['123', Stats.new(1,5)]] ; end
+  def self.unix_listener_stats(*) ; [['456', Stats.new(1,5)]] ; end
+end
+
+describe UnicornMetrics::Middleware do
+  before do
+    @resp_headers = { 'Content-Type' => 'text/plain', 'Content-Length' => '0' }
+    @response     = [ 200, @resp_headers, ["test_body"] ]
+    @app          = ->(env){ @response }
+
+    # Remove any metrics lingering from previous tests
+    UnicornMetrics.metrics.delete_if{true}
+
+    @counter    = UnicornMetrics.register(:counter, "test_counter")
+    options     = { metrics: '/metrics', listeners: %w(0.0.0.0:80) }
+    @middleware = UnicornMetrics::Middleware.new(@app, options)
+  end
+
+  after  { UnicornMetrics.metrics.delete("test_counter")}
+
+  describe "#call" do
+    context "when path matches the defined metrics path" do
+      before do
+        response = @middleware.call({'PATH_INFO' => '/metrics'})
+        @hash    =  JSON response[2][0]
+      end
+
+      it "returns the metrics response JSON body" do
+        @hash.fetch("test_counter").must_equal @counter.as_json.fetch("test_counter")
+      end
+
+      it "includes raindrops middleware metrics" do
+        @hash.must_include "raindrops.calling"
+        @hash.must_include "raindrops.writing"
+        @hash.must_include "raindrops.tcp.active"
+        @hash.must_include "raindrops.tcp.queued"
+      end
+    end
+
+    context "when the path does not match the defined metrics path" do
+      it "returns the expected response" do
+        response = @middleware.call({'PATH_INFO' => '/'})
+
+        # The Raindrops::Middleware wraps the response body in a Proxy
+        # Write the response body to a string to match the expectation
+        response[2] = [ response[2].inject(""){ |str, v| str << v } ]
+
+        response.must_equal @response
+      end
+    end
+  end
+
+end

data/test/test_registry.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+describe UnicornMetrics::Registry do
+  describe "METRIC_TYPES" do
+    it "returns a hash that maps type symbols to class names" do
+      hash = {
+        :counter          => 'Counter',
+        :timer            => 'Timer',
+        :response_counter => 'ResponseCounter',
+        :request_counter  => 'RequestCounter',
+        :request_timer    => 'RequestTimer'
+      }
+      UnicornMetrics::Registry::METRIC_TYPES.must_equal hash
+    end
+  end
+
+  describe ".register" do
+    before { UnicornMetrics.register(:counter,"test-counter") }
+    after  { UnicornMetrics.metrics.delete("test-counter")}
+
+    it "initializes and stores a new metric object" do
+      UnicornMetrics.metrics.fetch("test-counter").must_be_instance_of UnicornMetrics::Counter
+    end
+
+    it "defines getter method from the name of the metric with non-word chars replaced by '_'" do
+      UnicornMetrics.metrics.fetch("test-counter").must_be_same_as UnicornMetrics.test_counter
+    end
+
+    it "raises an error if a name is used twice" do
+      ->{UnicornMetrics.register(:counter, "test-counter")}.must_raise ArgumentError
+    end
+  end
+end
+

data/test/test_request_counter.rb

@@ -0,0 +1,56 @@
+require 'test_helper'
+
+describe UnicornMetrics::RequestCounter do
+  before do
+    @counter = UnicornMetrics::RequestCounter.new("test_counter", 'POST')
+    @counter.reset
+  end
+
+  describe ".counters" do
+    it "returns a collection of current RequestCounter instances" do
+      UnicornMetrics::RequestCounter.counters.must_include @counter
+    end
+  end
+
+  describe ".notify" do
+    it "increments all existing counters that match an http method and path" do
+      UnicornMetrics::RequestCounter.notify('POST','/')
+      @counter.value.must_equal 1
+    end
+  end
+
+  describe "#path_method_match?" do
+    context "when path is nil (not specified)" do
+      context "when method name matches" do
+        it "returns true" do
+          @counter.path_method_match?('POST', '/anything').must_equal true
+        end
+      end
+
+      context "when method name does not match" do
+        it "returns false" do
+          @counter.path_method_match?('GET', '/anything').must_equal false
+        end
+      end
+    end
+
+    context "when path is not nil (it is set)" do
+      before { @counter.instance_variable_set(:@path, /\/something/) }
+      after  { @counter.instance_variable_set(:@path, nil) }
+
+      context "when method matches" do
+        context "when patch matches" do
+          it "returns true" do
+            @counter.path_method_match?('POST', '/something').must_equal true
+          end
+        end
+
+        context "when patch does not match" do
+          it "returns false" do
+            @counter.path_method_match?('POST', '/bla').must_equal false
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_request_timer.rb

@@ -0,0 +1,56 @@
+require 'test_helper'
+
+describe UnicornMetrics::RequestTimer do
+  before do
+    @timer = UnicornMetrics::RequestTimer.new("test_timer", 'POST')
+    @timer.reset
+  end
+
+  describe ".timers" do
+    it "returns a collection of current RequestTimer instances" do
+      UnicornMetrics::RequestTimer.timers.must_include @timer
+    end
+  end
+
+  describe ".notify" do
+    it "ticks all existing timers that match an http method and path" do
+      UnicornMetrics::RequestTimer.notify('POST','/', 10.0)
+      @timer.sum.must_equal 10.0
+    end
+  end
+
+  describe "#path_method_match?" do
+    context "when path is nil (not specified)" do
+      context "when method name matches" do
+        it "returns true" do
+          @timer.path_method_match?('POST', '/anything').must_equal true
+        end
+      end
+
+      context "when method name does not match" do
+        it "returns false" do
+          @timer.path_method_match?('GET', '/anything').must_equal false
+        end
+      end
+    end
+
+    context "when path is not nil (it is set)" do
+      before { @timer.instance_variable_set(:@path, /\/something/) }
+      after  { @timer.instance_variable_set(:@path, nil) }
+
+      context "when method matches" do
+        context "when patch matches" do
+          it "returns true" do
+            @timer.path_method_match?('POST', '/something').must_equal true
+          end
+        end
+
+        context "when patch does not match" do
+          it "returns false" do
+            @timer.path_method_match?('POST', '/bla').must_equal false
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_response_counter.rb

@@ -0,0 +1,56 @@
+require 'test_helper'
+
+describe UnicornMetrics::ResponseCounter do
+  before do
+    @counter = UnicornMetrics::ResponseCounter.new("test_counter", /[2]\d{2}/)
+    @counter.reset
+  end
+
+  describe ".counters" do
+    it "returns a collection of current ResponseCounter instances" do
+      UnicornMetrics::ResponseCounter.counters.must_include @counter
+    end
+  end
+
+  describe ".notify" do
+    it "increments all existing counters that match a status code and path" do
+      UnicornMetrics::ResponseCounter.notify('200','/')
+      @counter.value.must_equal 1
+    end
+  end
+
+  describe "#path_status_match?" do
+    context "when path is nil (not specified)" do
+      context "when status name matches" do
+        it "returns true" do
+          @counter.path_status_match?('200', '/anything').must_equal true
+        end
+      end
+
+      context "when status name does not match" do
+        it "returns false" do
+          @counter.path_status_match?('400', '/anything').must_equal false
+        end
+      end
+    end
+
+    context "when path is not nil (it is set)" do
+      before { @counter.instance_variable_set(:@path, /\/something/) }
+      after  { @counter.instance_variable_set(:@path, nil) }
+
+      context "when status matches" do
+        context "when patch matches" do
+          it "returns true" do
+            @counter.path_status_match?('200', '/something').must_equal true
+          end
+        end
+
+        context "when patch does not match" do
+          it "returns false" do
+            @counter.path_status_match?('200', '/bla').must_equal false
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_timer.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+describe UnicornMetrics::Timer do
+  before do
+    @timer = UnicornMetrics::Timer.new("test_timer")
+    @timer.reset
+  end
+
+  describe "#type" do
+    it "returns 'timer'" do
+      @timer.type.must_equal 'timer'
+    end
+  end
+
+  context "when initialized" do
+    describe "#sum" do
+      it "must be zero" do
+        @timer.sum.must_equal 0.0
+      end
+    end
+
+    describe "#count" do
+      it "must be zero" do
+        @timer.count.must_equal 0
+      end
+    end
+  end
+
+  context "when ticked" do
+    describe "#sum" do
+      it "returns sum + elapsed time" do
+        @timer.tick(5)
+        @timer.sum.must_equal 5.0
+      end
+    end
+
+    describe "#count" do
+      it "returns the count of ticks" do
+        @timer.tick(5)
+        @timer.count.must_equal 1
+      end
+    end
+  end
+
+  describe "#reset" do
+    it "resets count and sum" do
+      5.times { @timer.tick(5) }
+      @timer.reset
+      @timer.sum.must_equal 0
+      @timer.count.must_equal 0
+    end
+  end
+
+  describe "#as_json" do
+    it "returns the JSON representation of the object as a hash" do
+      hash = {
+        @timer.name => {
+          "type"  => @timer.type,
+          "sum"   => @timer.sum,
+          "count" => @timer.count
+        }
+      }
+
+      @timer.as_json.must_equal hash
+    end
+  end
+
+  describe "forking" do
+    it "can be shared across processes" do
+      2.times { fork { @timer.tick(5) ; exit } }
+      Process.waitall
+      @timer.sum.must_equal 10.0
+      @timer.count.must_equal 2
+    end
+  end
+end

data/test/test_unicorn_metrics.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+describe UnicornMetrics do
+  describe "::registry" do
+    it "returns the UnicornMetrics::Registry object" do
+      UnicornMetrics.registry.must_equal UnicornMetrics::Registry
+    end
+  end
+
+  describe "::configure" do
+    it "yields self" do
+     ->{ UnicornMetrics.configure {|u| print u}}.must_output 'UnicornMetrics'
+    end
+  end
+
+  describe "::http_metrics=" do
+    context "when arg is false" do
+      it "should not extend Registry with DefaultHttpCounters module" do
+        UnicornMetrics.registry.wont_respond_to :register_default_http_counters
+      end
+    end
+
+    context "when arg is true" do
+      before { UnicornMetrics.http_metrics = true }
+
+      it "extends Registry with DefaultHttpMetrics module" do
+        UnicornMetrics.registry.must_respond_to :register_default_http_counters
+        UnicornMetrics.registry.must_respond_to :register_default_http_timers
+      end
+
+      it "registers the default http counters" do
+        UnicornMetrics.registry.metrics.keys.size.must_equal 9
+      end
+    end
+  end
+
+  it "delegates unknown methods to Registry" do
+    methods       = UnicornMetrics.registry.methods(false)
+    respond_count = 0
+    methods.each { |m| respond_count+=1 if UnicornMetrics.respond_to?(m) }
+    respond_count.must_equal methods.size
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: unicorn_metrics
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Alan Cohen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+- !ruby/object:Gem::Dependency
+  name: raindrops
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+description: 
+email:
+- acohen@climate.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/unicorn_metrics/counter.rb
+- lib/unicorn_metrics/default_http_metrics.rb
+- lib/unicorn_metrics/middleware.rb
+- lib/unicorn_metrics/registry.rb
+- lib/unicorn_metrics/request_counter.rb
+- lib/unicorn_metrics/request_timer.rb
+- lib/unicorn_metrics/response_counter.rb
+- lib/unicorn_metrics/timer.rb
+- lib/unicorn_metrics/version.rb
+- lib/unicorn_metrics.rb
+- test/test_counter.rb
+- test/test_helper.rb
+- test/test_middleware.rb
+- test/test_registry.rb
+- test/test_request_counter.rb
+- test/test_request_timer.rb
+- test/test_response_counter.rb
+- test/test_timer.rb
+- test/test_unicorn_metrics.rb
+homepage: http://www.climate.com
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- Preforking http server (i.e., Unicorn).
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Metrics library for Rack applications using a preforking http server (i.e.,
+  Unicorn)
+test_files:
+- test/test_counter.rb
+- test/test_helper.rb
+- test/test_middleware.rb
+- test/test_registry.rb
+- test/test_request_counter.rb
+- test/test_request_timer.rb
+- test/test_response_counter.rb
+- test/test_timer.rb
+- test/test_unicorn_metrics.rb
+has_rdoc: