yam-ruby-metrics 0.8.6

data/lib/ruby-metrics/integration.rb

@@ -0,0 +1,11 @@
+module Metrics
+  module Integration
+    
+    autoload :WEBrick, File.expand_path('../integration/webrick', __FILE__)
+    
+    module Rack
+      autoload :Middleware, File.expand_path('../integration/rack_middleware', __FILE__)
+      autoload :Endpoint,   File.expand_path('../integration/rack_endpoint', __FILE__)
+    end
+  end
+end

data/lib/ruby-metrics/integration/rack_endpoint.rb

@@ -0,0 +1,33 @@
+# Provides:
+# * configurable agent
+# * endpoint for accessing metrics JSON
+# 
+module Metrics
+  module Integration
+    module Rack
+      class Endpoint
+        
+        attr_accessor :app, :options, :agent,
+                      # integration metrics
+                      :requests, :uncaught_exceptions,
+                      :status_codes
+        
+        def initialize(options ={})
+          @options  = options
+          @agent    = @options.delete(:agent) || Agent.new
+        end
+        
+        def call(_)
+          body = @agent.to_json
+          
+          [ 200,
+            { 'Content-Type'    => 'application/json',
+              'Content-Length'  => body.size.to_s },
+            [body]
+          ]
+        end
+        
+      end
+    end
+  end
+end

data/lib/ruby-metrics/integration/rack_middleware.rb

@@ -0,0 +1,82 @@
+# Provides:
+# * configurable agent
+# * configurable endpoint for current metrics
+#   * strings == path_info
+#   * regexp =~ path_info
+#   * proc.call(env) #=> boolean
+# * env['metrics.agent'] upstream
+# * specific metrics by default
+#   * requests (timer)
+#   * uncaught_exceptions (counter)
+#   * response_1xx through response_5xx (counter)
+# 
+module Metrics
+  module Integration
+    module Rack
+      class Middleware
+        
+        attr_accessor :app, :options, :agent,
+                      # integration metrics
+                      :requests, :uncaught_exceptions,
+                      :status_codes
+        
+        def initialize(app, options ={})
+          @app      = app
+          @options  = {:show => "/stats"}.merge(options)
+          @agent    = @options.delete(:agent) || Agent.new
+          
+          # Integration Metrics
+          @requests             = @agent.timer(:_requests)
+          @uncaught_exceptions  = @agent.counter(:_uncaught_exceptions)
+          
+          # HTTP Status Codes
+          @status_codes = {
+            1 => @agent.counter(:_status_1xx),
+            2 => @agent.counter(:_status_2xx),
+            3 => @agent.counter(:_status_3xx),
+            4 => @agent.counter(:_status_4xx),
+            5 => @agent.counter(:_status_5xx)
+          }
+        end
+        
+        def call(env)
+          return show(env) if show?(env)
+          
+          env['metrics.agent'] = @agent
+          
+          status, headers, body = self.requests.time{ @app.call(env) }
+          
+          if status_counter = self.status_codes[status / 100]
+            status_counter.incr
+          end
+          
+          [status, headers, body]
+        rescue Exception
+          # TODO: add "last_uncaught_exception" with string of error
+          self.uncaught_exceptions.incr
+          raise
+        end
+        
+        def show?(env, test = self.options[:show])
+          case
+          when String === test;         env['PATH_INFO'] == test
+          when Regexp === test;         env['PATH_INFO'] =~ test
+          when test.respond_to?(:call); test.call(env)
+          else                          test
+          end
+        end
+        
+        def show(_)
+          body = @agent.to_json
+          
+          [ 200,
+            { 'Content-Type'    => 'application/json',
+              'Content-Length'  => body.size.to_s },
+            [body]
+          ]
+        end
+        
+      end
+    end
+  end
+end

data/lib/ruby-metrics/integration/webrick.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'ruby-metrics')
+
+require 'webrick'
+
+module Metrics
+  
+  class Agent
+    def start(options = {})
+      Integration::WEBrick.start(options.merge(:agent => self))
+    end
+  end
+  
+  module Integration
+    class WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
+      include Logging
+      
+      def self.start(options = {})
+        connection_options = {:Port => options.delete(:port) || options.delete(:Port) || 8001}
+        agent = options.delete(:agent) || Agent.new
+        
+        logger.debug "Creating Metrics daemon thread."
+        @thread = Thread.new do
+          begin
+            server = ::WEBrick::HTTPServer.new(connection_options)
+            server.mount "/stats", self, agent
+            server.start
+          rescue Exception => e
+            logger.error "Error in thread: %s: %s\n\t%s" % [e.class.to_s,
+                                                            e.message,
+                                                            e.backtrace.join("\n\t")]
+          end
+        end
+      end
+      
+      def initialize(server, agent)
+        @agent = agent
+      end
+      
+      def do_GET(request, response)
+        response.status           = 200
+        response['Content-Type']  = 'application/json'
+        response.body             = @agent.to_json
+      end
+      
+    end
+  end
+end

data/lib/ruby-metrics/logging.rb

@@ -0,0 +1,19 @@
+module Metrics
+  module Logging
+    
+    def self.included(target)
+      target.extend ClassMethods
+    end
+    
+    def logger
+      self.class.logger
+    end
+    
+    module ClassMethods
+      def logger
+        Metrics.logger
+      end
+    end
+    
+  end
+end

data/lib/ruby-metrics/statistics/exponential_sample.rb

@@ -0,0 +1,91 @@
+module Metrics
+  module Statistics
+    class ExponentialSample
+      def initialize(size = 1028, alpha = 0.015)
+        @values = Hash.new
+        @count  = 0
+        @size   = size
+        @alpha  = alpha
+        @rescale_window = 3600  #seconds -- 1 hour
+        self.clear
+      end
+      
+      def clear
+        @values           = Hash.new
+        @start_time       = tick
+        @next_scale_time  = Time.now.to_f + @rescale_window
+        @count            = 0
+      end
+      
+      def size
+        [@values.keys.length, @count].min
+      end
+      
+      def tick
+        Time.now.to_f
+      end
+      
+      def update(value)
+        update_with_timestamp(value, tick)
+      end
+      
+      def update_with_timestamp(value, timestamp)
+        priority = weight(timestamp.to_f - @start_time.to_f) / rand
+        @count += 1
+        newcount = @count
+        if (newcount <= @size)
+          @values[priority] = value
+        else
+          firstkey = @values.keys[0]
+          if (firstkey < priority)
+            @values[priority] = value
+            
+            while(@values.delete(firstkey) == nil)
+              firstkey = @values.keys[0]
+            end
+          end
+        end
+        
+        now = Time.now.to_f
+        next_scale_time = @next_scale_time
+        
+        if (now >= next_scale_time)
+          self.rescale(now, next_scale_time)
+        end
+      end
+      
+      
+      def rescale(now, next_scale_time)
+        if @next_scale_time == next_scale_time
+          # writelock
+          @next_scale_time = now + @rescale_window
+          old_start_time = @start_time
+          @start_time = tick
+          time_delta = @start_time - old_start_time
+          keys = @values.keys
+          keys.each do |key|
+            value = @values.delete(key)
+            new_key = (key * Math.exp(-@alpha * time_delta))
+            @values[new_key] = value
+          end
+          # unlock
+        end  
+      end
+      
+      def weight(factor)
+        return @alpha.to_f * factor.to_f
+      end
+      
+      def values
+        # read-lock?
+        result = Array.new
+        keys = @values.keys.sort
+        keys.each do |key|
+          result << @values[key]
+        end
+        
+        result
+      end
+    end
+  end
+end

data/lib/ruby-metrics/statistics/uniform_sample.rb

@@ -0,0 +1,37 @@
+module Metrics
+  module Statistics
+    class UniformSample
+      def initialize(size = 1028)
+        @values = Array.new(size)
+        @count = 0
+        @size = size
+        self.clear
+      end
+      
+      def clear
+        (0..@values.length-1).each do |i|
+          @values[i] = 0
+        end
+        @count = 0
+      end
+      
+      def size
+        @values.length
+      end
+      
+      def update(value)
+        if @count < @values.length
+          @values[@count] = value
+          @count += 1
+        else
+          index = rand(@size) % @count
+          @values[index] = value
+        end
+      end
+      
+      def values
+        @values.dup
+      end
+    end
+  end
+end

data/lib/ruby-metrics/time_units.rb

@@ -0,0 +1,61 @@
+module Metrics
+  
+  class TimeUnit 
+    def self.to_nsec(mult = 1)
+      raise NotImplementedError
+    end
+  end
+  
+  class Nanoseconds < TimeUnit
+    def self.to_nsec(mult = 1)
+      mult
+    end
+  end
+  
+  class Microseconds < TimeUnit
+    def self.to_nsec(mult = 1)
+      1000 * mult
+    end
+  end
+  
+  class Milliseconds < TimeUnit
+    def self.to_nsec(mult = 1)
+      1000000 * mult
+    end
+  end
+  
+  class Seconds < TimeUnit
+    def self.to_nsec(mult = 1)
+      1000000000 * mult
+    end
+  end
+  
+  class Minutes < TimeUnit
+    def self.to_nsec(mult = 1)
+      60000000000 * mult
+    end
+  end
+  
+  class Hours < TimeUnit
+    def self.to_nsec(mult = 1)
+      3600000000000 * mult
+    end
+  end
+  
+  module TimeConversion
+   
+  
+    def convert_to_ns(value, unit)
+      units = {
+          :nanoseconds            => Nanoseconds,
+          :microseconds           => Microseconds,
+          :milliseconds           => Milliseconds,
+          :seconds                => Seconds,
+          :minutes                => Minutes,
+          :hours                  => Hours
+      }
+      
+      units[unit].to_nsec * value
+    end
+  end
+end

data/lib/ruby-metrics/version.rb

@@ -0,0 +1,3 @@
+module Metrics
+  VERSION = "0.8.6"
+end

data/ruby-metrics.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ruby-metrics/version"
+
+Gem::Specification.new do |s|
+  s.name        = "yam-ruby-metrics"
+  s.version     = Metrics::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["John Ewart"]
+  s.email       = ["john@johnewart.net"]
+  s.homepage    = "https://github.com/johnewart/ruby-metrics"
+  s.summary     = %q{Metrics for Ruby}
+  s.description = %q{A Ruby implementation of metrics inspired by @coda's JVM metrics for those of us in Ruby land}
+
+  s.rubyforge_project = "yam-ruby-metrics"
+
+  s.add_dependency "json"
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "simplecov", [">= 0.3.8"] #, :require => false
+  s.add_development_dependency "rack-test"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/agent_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper.rb'
+
+describe Metrics::Agent do
+  before :each do 
+    @agent = Metrics::Agent.new
+  end
+  
+  it "should create a new agent" do  
+  end
+  
+  it "should add a counter instrument correctly" do 
+    @counter = Metrics::Instruments::Counter.new
+    Metrics::Instruments::Counter.stub!(:new).and_return @counter
+    @agent.counter(:test_counter).should == @counter
+  end
+  
+  it "should allow for creating a gauge with a block via #gauge" do 
+    @agent.gauge :test_gauge do 
+      "result"
+    end
+  end
+  
+  it "should add a Histogram instrument using uniform sampling" do
+    histogram = Metrics::Instruments::UniformHistogram.new
+    Metrics::Instruments::UniformHistogram.stub!(:new).and_return histogram
+    @agent.uniform_histogram(:test_histogram).should == histogram
+  end
+
+  it "should allow for registering a Histogram instrument using exponentially decaying sampling" do
+    histogram = Metrics::Instruments::ExponentialHistogram.new
+    Metrics::Instruments::ExponentialHistogram.stub!(:new).and_return histogram
+    @agent.exponential_histogram(:test_histogram).should == histogram
+  end  
+
+  it "should set up a histogram using uniform distribution if just a histogram is registered" do
+    histogram = Metrics::Instruments::UniformHistogram.new
+    Metrics::Instruments::UniformHistogram.stub!(:new).and_return histogram
+    @agent.histogram(:test_histogram).should == histogram
+  end
+  
+  it "should add a meter instrument correctly" do
+    @meter = Metrics::Instruments::Meter.new
+    Metrics::Instruments::Meter.stub!(:new).and_return @meter
+
+    @agent.meter(:test_meter).should == @meter
+  end
+  
+end