metrics-rails 0.1.0

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2012. Librato, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL LIBRATO, INC. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,105 @@
+metrics-rails
+=======
+
+[![Build Status](https://secure.travis-ci.org/librato/metrics-rails.png?branch=master)](http://travis-ci.org/librato/metrics-rails)
+
+Report key statistics for your Rails app to [Librato Metrics](https://metrics.librato.com/), easily track your own custom metrics. Currently supports Rails 3.0+.
+
+**NOTE: This is currently in alpha development and is not yet officially supported**
+
+## Installation
+
+In your `Gemfile` add:
+
+    gem 'metrics-rails'
+    
+Then run `bundle install`.
+
+## Configuration
+
+If you don't have a Metrics account already, [sign up](https://metrics.librato.com/). In order to send measurements to Metrics you need to provide your account credentials to `metrics-rails`. You can provide these one of two ways:
+
+Create a `config/metrics.yml` like the following:
+
+    production:
+      email: <your-email>
+      api_key: <your-api-key>
+      
+OR provide `METRICS_EMAIL` and `METRICS_API_KEY` environment variables. If both env variables and a config file are present, environment variables will take precendence.
+
+Note that using a configuration file allows you to specify configurations per-environment. Submission will be disabled in any environment without credentials. However, if environment variables are set they will be used in all environments. 
+
+Full information on configuration options is available on the [configuration wiki page](https://github.com/librato/metrics-rails/wiki/Configuration).
+
+## Automatic Measurements
+
+After installing `metrics-rails` and restarting your app and you will see a number of new metrics appear in your Metrics account. These track request performance, sql queries, mail handling, and other key stats. All built-in performance metrics start with the prefix `rails` by convention &mdash; for example: `rails.request.total` is the total number of requests received during an interval. 
+
+If you have multiple apps reporting to the same Metrics account you can change this prefix in your [configuration](https://github.com/librato/metrics-rails/wiki/Configuration).
+
+## Custom Measurements
+
+Tracking anything that interests you is easy with Metrics. There are four primary helpers available:
+
+#### increment
+
+Use for tracking a running total of something _across_ requests, examples:
+
+    # increment the 'sales_completed' metric by one
+    Metrics.increment 'sales_completed'
+    
+    # increment by five
+    Metrics.increment 'items_purchased', 5
+    
+Other things you might track this way: user signups, requests of a certain type or to a certain route, total jobs queued or processed, emails sent or received
+
+#### measure
+
+Use when you want to track an average value _per_-request. Examples:
+
+    Metrics.measure 'user.social_graph.nodes', 212
+
+    Metrics.measure 'jobs.queued', 3
+    
+
+#### timing
+
+Like `Metrics.measure` this is per-request, but specialized for timing information:
+
+    Metrics.timing 'twitter.lookup.time', 21.2
+	
+The block form auto-submits the time it took for its contents to execute as the measurement value:
+
+    Metrics.timing 'twitter.lookup.time' do
+      @twitter = Twitter.lookup(user)
+    end
+
+#### group
+
+There is also a grouping helper, to make managing nested metrics easier. So this:
+
+    Metrics.measure 'memcached.gets', 20
+    Metrics.measure 'memcached.sets', 2
+    Metrics.measure 'memcached.hits', 18
+    
+Can also be written as:
+
+    Metrics.group 'memcached' do |g|
+      g.measure 'gets', 20
+      g.measure 'sets', 2
+      g.measure 'hits', 18
+    end
+
+Symbols can be used interchangably with strings for metric names.
+
+## Contribution
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project and submit a pull request from a feature or bugfix branch.
+* Please include tests. This is important so we don't break your changes unintentionally in a future version.
+* Please don't modify the gemspec, Rakefile, version, or changelog. If you do change these files, please isolate a separate commit so we can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2012 [Librato Inc.](http://librato.com) See LICENSE for details.

data/Rakefile

@@ -0,0 +1,41 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'MetricsRails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+# IRB
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "pry -rubygems -r rails -r ./lib/metrics-rails.rb"
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/lib/metrics-rails.rb

@@ -0,0 +1 @@
+require 'metrics/rails'

data/lib/metrics/rails.rb

@@ -0,0 +1,226 @@
+require 'socket'
+require 'thread'
+
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/notifications'
+require 'librato/metrics'
+
+require 'metrics/rails/aggregator'
+require 'metrics/rails/counter_cache'
+require 'metrics/rails/group'
+require 'metrics/rails/helpers'
+require 'metrics/rails/worker'
+require 'metrics/rails/version'
+
+module Metrics
+  extend SingleForwardable
+  def_delegators Metrics::Rails, :increment, :measure, :timing, :group
+  
+  module Rails
+    extend SingleForwardable
+    CONFIG_SETTABLE = %w{api_key email flush_interval prefix source}
+    
+    mattr_accessor :config_file
+    
+    # config options
+    mattr_accessor :api_key
+    mattr_accessor :email
+    mattr_accessor :flush_interval
+    mattr_accessor :prefix
+    
+    # config defaults
+    self.flush_interval = 60 # seconds
+    self.prefix = 'rails'
+    
+    def_delegators :counters, :increment
+    def_delegators :aggregate, :measure, :timing
+
+    class << self
+    
+      # access to internal aggregator object
+      def aggregate
+        @aggregator_cache ||= Aggregator.new
+      end
+      
+      # set custom api endpoint
+      def api_endpoint=(endpoint)
+        @api_endpoint = endpoint
+      end
+    
+      # access to client instance
+      def client
+        @client ||= prepare_client
+      end
+      
+      # detect / update configuration
+      def check_config
+        if self.config_file && File.exists?(self.config_file)
+          configs = YAML.load_file(config_file)
+          if env_specific = configs[::Rails.env]
+            settable = CONFIG_SETTABLE & env_specific.keys
+            settable.each { |key| self.send("#{key}=", env_specific[key]) }
+          end
+        end
+        self.api_key = ENV['METRICS_API_KEY'] if ENV['METRICS_API_KEY']
+        self.email = ENV['METRICS_EMAIL'] if ENV['METRICS_EMAIL']
+      end
+      
+      # check to see if we've forked into a process where a worker
+      # isn't running yet, if so start it up!
+      def check_worker
+        if @pid != $$
+          start_worker
+          #aggregate.clear
+          #counters.clear
+        end
+      end
+  
+      # access to internal counters object
+      def counters
+        @counter_cache ||= CounterCache.new
+      end
+      
+      # remove any accumulated but unsent metrics
+      def delete_all
+        aggregate.delete_all
+        counters.delete_all
+      end
+      
+      # catches request-environment specific things we can't
+      # find through another means.
+      def evaluate_request(request)
+        if request.env.keys.include?('HTTP_X_HEROKU_QUEUE_DEPTH')
+          # heroku
+          group "#{prefix}.heroku" do |h|
+            h.measure 'queue.depth', request.env['HTTP_X_HEROKU_QUEUE_DEPTH'].to_f
+            h.timing 'queue.wait_time', request.env['HTTP_X_HEROKU_QUEUE_WAIT_TIME'].to_f
+            h.measure 'queue.dynos', request.env['HTTP_X_HEROKU_DYNOS_IN_USE'].to_f
+          end
+        end
+      end
+      
+      # send all current data to Metrics
+      def flush
+        logger.debug "[metrics-rails] flushing #{Process.pid} (#{Time.now}):"
+        queue = client.new_queue(:source => qualified_source)
+        # thread safety is handled internally for both stores
+        counters.flush_to(queue)
+        aggregate.flush_to(queue)
+        logger.debug queue.queued
+        queue.submit unless queue.empty?
+      rescue Exception => error
+        logger.error "[metrics-rails] submission failed permanently, worker exiting: #{error}"
+      end
+      
+      def group(prefix)
+        group = Group.new(prefix)
+        yield group
+      end
+      
+      def logger
+        @logger ||= ::Rails.logger
+      end
+      
+      # source including process pid
+      def qualified_source
+        "#{source}.#{$$}"
+      end
+      
+      # run once during Rails startup sequence
+      def setup
+        check_config
+        #return unless self.email && self.api_key
+        logger.info "[metrics-rails] starting up with #{app_server}..."
+        @pid = $$
+        install_request_evaluator
+        if forking_server?
+          install_worker_check
+        else
+          start_worker # start immediately
+        end
+      end
+      
+      def source
+        @source ||= Socket.gethostname
+      end
+      
+      # set a custom source
+      def source=(src)
+        @source = src
+      end
+      
+      # start the worker thread, one is needed per process.
+      # if this process has been forked from an one with an active
+      # worker thread we don't need to worry about cleanup as only
+      # the forking thread is copied.
+      def start_worker
+        return if @worker # already running
+        @pid = $$
+        logger.debug "[metrics-rails] >> starting up worker for pid #{@pid}..."
+        @worker = Thread.new do
+          worker = Worker.new
+          worker.run_periodically(self.flush_interval) do
+            flush
+          end
+        end
+      end
+      
+    private
+
+      def app_server
+        if defined?(::Unicorn) && defined?(::Unicorn::HttpServer) && !::Unicorn.listener_names.empty?
+          :unicorn
+        elsif defined?(::IN_PHUSION_PASSENGER) || (defined?(::Passenger) && defined?(::Passenger::AbstractServer))
+          :passenger
+        elsif defined?(::Thin) && defined?(::Thin::Server)
+          :thin
+        else
+          :other
+        end
+      end
+    
+      def forking_server?
+        %w{unicorn passenger}.include?(app_server.to_s)
+      end
+      
+      def install_worker_check
+        ::ApplicationController.prepend_before_filter do |c| 
+          Metrics::Rails.check_worker
+        end
+      end
+      
+      def install_request_evaluator
+        ::ApplicationController.prepend_before_filter do |c| 
+          Metrics::Rails.evaluate_request(request)
+        end
+      end
+    
+      def prepare_client
+        check_config
+        client = Librato::Metrics::Client.new
+        client.authenticate email, api_key
+        client.api_endpoint = @api_endpoint if @api_endpoint
+        client.custom_user_agent = user_agent
+        client
+      end
+      
+      def ruby_engine
+        return RUBY_ENGINE if Object.constants.include?(:RUBY_ENGINE)
+        RUBY_DESCRIPTION.split[0]
+      end
+      
+      def user_agent
+        ua_chunks = []
+        ua_chunks << "metrics-rails/#{Metrics::Rails::VERSION}"
+        ua_chunks << "(#{ruby_engine}; #{RUBY_VERSION}p#{RUBY_PATCHLEVEL}; #{RUBY_PLATFORM}; #{app_server})"
+        ua_chunks.join(' ')
+      end
+    
+    end # end class << self
+
+  end
+end
+
+# must load after all module setup
+require 'metrics/rails/railtie'
+require 'metrics/rails/subscribers'

data/lib/metrics/rails/aggregator.rb

@@ -0,0 +1,48 @@
+module Metrics
+  module Rails
+    class Aggregator
+      extend Forwardable
+      
+      def_delegators :@cache, :empty?
+      
+      def initialize
+        @cache = Librato::Metrics::Aggregator.new
+        @lock = Mutex.new
+      end
+      
+      def [](key)
+        return nil if @cache.empty?
+        gauges = nil
+        @lock.synchronize { gauges = @cache.queued[:gauges] }
+        gauges.each do |metric|
+          return metric if metric[:name] == key.to_s
+        end
+        nil
+      end
+      
+      def delete_all
+        @lock.synchronize { @cache.clear }
+      end
+      
+      # transfer all measurements to a queue and 
+      # reset internal status
+      def flush_to(queue, options={})
+        queued = nil
+        @lock.synchronize do
+          return if @cache.empty?
+          queued = @cache.queued
+          @cache.clear
+        end
+        queue.merge!(queued) if queued
+      end
+      
+      def measure(event, duration)
+        @lock.synchronize do
+          @cache.add event.to_s => duration
+        end
+      end
+      alias :timing :measure
+      
+    end
+  end
+end