librato-rails 0.9.0 → 0.10.0.pre1

data/lib/librato/rails.rb

@@ -1,215 +1,10 @@
-require 'socket'
-require 'thread'
-
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/notifications'
-require 'librato/metrics'
-
 require 'librato/rack'
-require 'librato/rails/aggregator'
-require 'librato/rails/collector'
-require 'librato/rails/configuration'
-require 'librato/rails/counter_cache'
-require 'librato/rails/group'
-require 'librato/rails/logging'
-require 'librato/rails/validating_queue'
-require 'librato/rails/version'
-require 'librato/rails/worker'
-
-module Librato
-  extend SingleForwardable
-  def_delegators Librato::Rails, :increment, :measure, :timing, :group
-
-  module Rails
-    extend SingleForwardable
-    extend Librato::Rails::Configuration
-    extend Librato::Rails::Logging
-
-    FORKING_SERVERS = [:unicorn, :passenger]
-    SOURCE_REGEX = /\A[-:A-Za-z0-9_.]{1,255}\z/
-
-    # config options
-    mattr_accessor :user
-    mattr_accessor :token
-    mattr_accessor :flush_interval
-    mattr_accessor :source_pids
-
-    # config defaults
-    self.flush_interval = 60 # seconds
-    self.source_pids = false # append process id to the source?
-    # log_level (default :info)
-    # source (default: your machine's hostname)
-
-    # handy introspection
-    mattr_accessor :explicit_source
-
-    # a collector instance handles all measurement addition/storage
-    def_delegators :collector, :aggregate, :counters, :delete_all, :group, :increment,
-                               :measure, :prefix, :prefix=, :timing
-
-    class << self
-
-      # 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 client instance
-      def client
-        @client ||= prepare_client
-      end
-
-      # collector instance which is tracking all measurement additions
-      def collector
-        @collector ||= Collector.new
-      end
-
-      # send all current data to Metrics
-      def flush
-        log :debug, "flushing pid #{@pid} (#{Time.now}).."
-        start = Time.now
-        queue = flush_queue
-        # thread safety is handled internally for both stores
-        counters.flush_to(queue)
-        aggregate.flush_to(queue)
-        trace_queued(queue.queued) if should_log?(:trace)
-        queue.submit unless queue.empty?
-        log :trace, "flushed pid #{@pid} in #{(Time.now - start)*1000.to_f}ms"
-      rescue Exception => error
-        log :error, "submission failed permanently: #{error}"
-      end
-
-      # source including process pid
-      def qualified_source
-        self.source_pids ? "#{source}.#{$$}" : source
-      end
-
-      # run once during Rails startup sequence
-      def setup(app)
-        check_config
-        trace_settings if should_log?(:debug)
-        return unless should_start?
-        if app_server == :other
-          log :info, "starting up..."
-        else
-          log :info, "starting up with #{app_server}..."
-        end
-        @pid = $$
-        app.middleware.use Librato::Rack::Middleware
-        start_worker unless forking_server?
-      end
-
-      def source
-        return @source if @source
-        self.explicit_source = false
-        @source = Socket.gethostname
-      end
-
-      # set a custom source
-      def source=(src)
-        self.explicit_source = true
-        @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 = $$
-        log :debug, ">> 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?(::PhusionPassenger)
-          :passenger
-        elsif defined?(::Thin) && defined?(::Thin::Server)
-          :thin
-        else
-          :other
-        end
-      end
-
-      def flush_queue
-        ValidatingQueue.new(
-          :client => client,
-          :source => qualified_source,
-          :prefix => self.prefix,
-          :skip_measurement_times => true )
-      end
-
-      def forking_server?
-        FORKING_SERVERS.include?(app_server)
-      end
-
-      def on_heroku
-        # would be nice to have something more specific here,
-        # but nothing characteristic in ENV, etc.
-        @on_heroku ||= source_is_uuid?(Socket.gethostname)
-      end
-
-      def prepare_client
-        check_config
-        client = Librato::Metrics::Client.new
-        client.authenticate user, token
-        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 should_start?
-        if !self.user || !self.token
-          # don't show this unless we're debugging, expected behavior
-          log :debug, 'halting: credentials not present.'
-          false
-        elsif qualified_source !~ SOURCE_REGEX
-          log :warn, "halting: '#{qualified_source}' is an invalid source name."
-          false
-        elsif !explicit_source && on_heroku
-          log :warn, 'halting: source must be provided in configuration.'
-          false
-        else
-          true
-        end
-      end
-
-      def source_is_uuid?(source)
-        source =~ /[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/i
-      end
-
-      def user_agent
-        ua_chunks = []
-        ua_chunks << "librato-rails/#{Librato::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 'librato/rails/railtie' if defined?(Rails)
-require 'librato/rails/subscribers'
+require_relative 'rails/configuration'
+require_relative 'rails/tracker'
+require_relative 'rails/version'
+
+# must load after all module setup and in this order
+if defined?(Rails)
+  require_relative 'rails/railtie'
+  require_relative 'rails/subscribers'
+end

data/test/dummy/app/assets/javascripts/application.js

@@ -10,6 +10,3 @@
 // WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
 // GO AFTER THE REQUIRES BELOW.
 //
-//= require jquery
-//= require jquery_ujs
-//= require_tree .

data/test/dummy/app/controllers/cache_controller.rb

@@ -0,0 +1,44 @@
+class CacheController < ApplicationController
+  before_filter :instrument_caching
+  after_filter  :clear_cache
+
+  def read
+    Rails.cache.write('myfoo', 'bar', expires_in: 60.seconds)
+    Rails.cache.read('myfoo')
+    render :nothing => true
+  end
+
+  def write
+    Rails.cache.write('myfoo', 'bar', expires_in: 60.seconds)
+    render :nothing => true
+  end
+
+  def fetch_hit
+    Rails.cache.write('myfetch', 'bar', expires_in: 60.seconds)
+    Rails.cache.fetch('myfetch', expires_in: 60.seconds) { "populate" }
+    render :nothing => true
+  end
+
+  def generate
+    Rails.cache.fetch('newdata', expires_in: 60.seconds) { "populate" }
+    render :nothing => true
+  end
+
+  def delete
+    Rails.cache.write('something', 'bar', expires_in: 60.seconds)
+    Rails.cache.delete('something')
+    render :nothing => true
+  end
+
+  private
+
+  def clear_cache
+    Rails.cache.clear
+  end
+
+  def instrument_caching
+    # ensure caching instrumentation is turned on
+    Rails.cache.class.instrument = true
+  end
+
+end

data/test/dummy/app/controllers/render_controller.rb

@@ -0,0 +1,4 @@
+class RenderController < ApplicationController
+  def render_partial; end
+  def render_template; end
+end

data/test/dummy/app/models/user.rb

@@ -1,17 +1,19 @@
 class User < ActiveRecord::Base
-  attr_accessible :email, :password
-  
+  if Rails.version[0] == '3'
+    attr_accessible :email, :password
+  end
+
   def self.do_custom_events
     Librato.group 'custom.model' do |g|
       g.increment 'lookups', 3
-      
+
       g.timing 'search', 12.3
       g.timing 'search', 6.7
-      
+
       g.measure 'total', 12
     end
   end
-  
+
   def touch
     Librato.increment 'custom.model.touch'
   end

data/test/dummy/app/views/render/_first.html.erb

@@ -0,0 +1 @@
+first

data/test/dummy/app/views/render/_second.html.erb

@@ -0,0 +1 @@
+second

data/test/dummy/app/views/render/partial.html.erb

@@ -0,0 +1,2 @@
+<%= render :partial => 'first' %>
+<%= render :partial => 'second' %>

data/test/dummy/app/views/render/template.html.erb

@@ -0,0 +1 @@
+Render that template

data/test/dummy/config/application.rb

@@ -43,18 +43,20 @@ module Dummy
     # like if you have constraints or database-specific column types
     # config.active_record.schema_format = :sql
 
-    # Enforce whitelist mode for mass assignment.
-    # This will create an empty whitelist of attributes available for mass-assignment for all models
-    # in your app. As such, your models will need to explicitly whitelist or blacklist accessible
-    # parameters by using an attr_accessible or attr_protected declaration.
-    config.active_record.whitelist_attributes = true
+    if Rails.version[0] == '3'
+      # Enforce whitelist mode for mass assignment.
+      # This will create an empty whitelist of attributes available for mass-assignment for all models
+      # in your app. As such, your models will need to explicitly whitelist or blacklist accessible
+      # parameters by using an attr_accessible or attr_protected declaration.
+      config.active_record.whitelist_attributes = true
+    end
 
     # Enable the asset pipeline
     config.assets.enabled = true
 
     # Version of your assets, change this if you want to expire all your assets
     config.assets.version = '1.0'
-    
+
     # set librato_rails prefix
     # config.librato_rails.prefix = 'dummy'
     config.librato_rails.flush_interval = 5

data/test/dummy/config/environments/test.rb

@@ -30,7 +30,7 @@ Dummy::Application.configure do
   config.action_mailer.delivery_method = :test
 
   # Raise exception on mass assignment protection for Active Record models
-  config.active_record.mass_assignment_sanitizer = :strict
+  # config.active_record.mass_assignment_sanitizer = :strict
 
   # Print deprecation notices to the stderr
   config.active_support.deprecation = :stderr

data/test/dummy/config/routes.rb

@@ -1,13 +1,22 @@
 Dummy::Application.routes.draw do
 
   get "status/:code" => 'status#index'
-  
+
   get 'exception' => 'home#boom',   :as => :exception
   get 'slow'      => 'home#slow',   :as => :slow
   get 'custom'    => 'home#custom', :as => :custom
-  
+
   get 'user/manipulation' => 'user#manipulation', :as => :user_manipulation
 
+  get 'cache/read'      => 'cache#read',      :as => :cache_read
+  get 'cache/write'     => 'cache#write',     :as => :cache_write
+  get 'cache/fetch_hit' => 'cache#fetch_hit', :as => :cache_fetch_hit
+  get 'cache/generate'  => 'cache#generate',  :as => :cache_generate
+  get 'cache/delete'    => 'cache#delete',    :as => :cache_delete
+
+  get 'render/partial'  => 'render#partial',  :as => :render_partial
+  get 'render/template' => 'render#template', :as => :render_template
+
   # The priority is based upon order of creation:
   # first created -> highest priority.
 
@@ -58,5 +67,5 @@ Dummy::Application.routes.draw do
   # You can have the root of your site routed with "root"
   # just remember to delete public/index.html.
   root :to => 'home#index'
-  
+
 end

data/test/integration/cache_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class CacheTest < ActiveSupport::IntegrationCase
+
+  test 'cache read' do
+    visit cache_read_path
+
+    assert_equal 1, counters["rails.cache.read"]
+    assert_equal 1, aggregate["rails.cache.read.time"][:count]
+  end
+
+  test 'cache write' do
+    visit cache_write_path
+
+    assert_equal 1, counters["rails.cache.write"]
+    assert_equal 1, aggregate["rails.cache.write.time"][:count]
+  end
+
+  test 'cache fetch_hit' do
+    visit cache_fetch_hit_path
+
+    assert_equal 1, counters["rails.cache.fetch_hit"]
+    assert_equal 1, aggregate["rails.cache.fetch_hit.time"][:count]
+  end
+
+  test 'cache generate' do
+    visit cache_generate_path
+
+    assert_equal 1, counters["rails.cache.generate"]
+    assert_equal 1, aggregate["rails.cache.generate.time"][:count]
+  end
+
+  test 'cache delete' do
+    visit cache_delete_path
+
+    assert_equal 1, counters["rails.cache.delete"]
+    assert_equal 1, aggregate["rails.cache.delete.time"][:count]
+  end
+
+end

data/test/integration/mail_test.rb

@@ -1,13 +1,11 @@
 require 'test_helper'
 
 class MailTest < ActiveSupport::IntegrationCase
-  
-  # Query tests - the numbers specified assume running against SQLite
-  
+
   test 'mail sent' do
     user = User.create!(:email => 'foo@foo.com', :password => 'wow')
     UserMailer.welcome_email(user).deliver
     assert_equal 1, counters["rails.mail.sent"]
   end
-  
+
 end

data/test/integration/render_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class RenderTest < ActiveSupport::IntegrationCase
+
+  test 'render partial' do
+    visit render_partial_path
+
+    assert_equal 1, counters.fetch("rails.view.render_partial",
+                                      source: 'render:first.html.erb')
+    assert_equal 1, counters.fetch("rails.view.render_partial",
+                                      source: 'render:second.html.erb')
+    assert_equal 1, aggregate.fetch("rails.view.render_partial.time",
+                                      source: 'render:first.html.erb')[:count]
+    assert_equal 1, aggregate.fetch("rails.view.render_partial.time",
+                                      source: 'render:second.html.erb')[:count]
+  end
+
+  test 'render template' do
+    visit render_template_path
+
+    assert_equal 1, counters.fetch("rails.view.render_template",
+                                      source: 'render:template.html.erb')
+    assert_equal 1, aggregate.fetch("rails.view.render_template.time",
+                                      source: 'render:template.html.erb')[:count]
+  end
+
+end

data/test/integration/request_test.rb

@@ -1,37 +1,41 @@
 require 'test_helper'
 
 class RequestTest < ActiveSupport::IntegrationCase
-  
+
   # Each request
-  
+
   test 'increment total and status' do
     visit root_path
-    
+
     assert_equal 1, counters["rails.request.total"]
     assert_equal 1, counters["rails.request.status.200"]
     assert_equal 1, counters["rails.request.status.2xx"]
-    
+    assert_equal 1, counters["rails.request.method.get"]
+
     visit '/status/204'
-    
+
     assert_equal 2, counters["rails.request.total"]
     assert_equal 1, counters["rails.request.status.200"]
     assert_equal 1, counters["rails.request.status.204"]
     assert_equal 2, counters["rails.request.status.2xx"]
   end
-  
+
   test 'request times' do
     visit root_path
-    
+
     # common for all paths
     assert_equal 1, aggregate["rails.request.time"][:count], 'should record total time'
     assert_equal 1, aggregate["rails.request.time.db"][:count], 'should record db time'
     assert_equal 1, aggregate["rails.request.time.view"][:count], 'should record view time'
-    
+
     # status specific
     assert_equal 1, aggregate["rails.request.status.200.time"][:count]
     assert_equal 1, aggregate["rails.request.status.2xx.time"][:count]
+
+    # http method specific
+    assert_equal 1, aggregate["rails.request.method.get.time"][:count]
   end
-  
+
   test 'track exceptions' do
     begin
       visit exception_path #rescue nil
@@ -40,10 +44,10 @@ class RequestTest < ActiveSupport::IntegrationCase
     end
     assert_equal 1, counters["rails.request.exceptions"]
   end
-  
+
   test 'track slow requests' do
     visit slow_path
     assert_equal 1, counters["rails.request.slow"]
   end
-  
+
 end

data/test/integration/sql_test.rb

@@ -1,28 +1,28 @@
 require 'test_helper'
 
 class SQLTest < ActiveSupport::IntegrationCase
-  
+
   # Query tests - the numbers specified assume running against SQLite
-  
+
   test 'total queries and query types' do
     # note that modifying queries are wrapped in a transaction which
     # adds 2 to total queries per operation.
     user = User.create!(:email => 'foo@foo.com', :password => 'wow')
     assert_equal 3, counters["rails.sql.queries"]
     assert_equal 1, counters["rails.sql.inserts"]
-    
+
     foo = User.find_by_email('foo@foo.com')
     assert_equal 4, counters["rails.sql.queries"]
     assert_equal 1, counters["rails.sql.selects"]
-    
+
     foo.password = 'new password'
     foo.save
     assert_equal 7, counters["rails.sql.queries"]
     assert_equal 1, counters["rails.sql.updates"]
-    
+
     foo.destroy
     assert_equal 10, counters["rails.sql.queries"]
     assert_equal 1, counters["rails.sql.deletes"]
   end
-  
+
 end

data/test/support/integration_case.rb

@@ -1,19 +1,23 @@
 class ActiveSupport::IntegrationCase < ActiveSupport::TestCase
   include Capybara::DSL
   include Rails.application.routes.url_helpers
-  
+
   setup do
     # remove any accumulated metrics
-    Librato::Rails.delete_all
+    collector.delete_all
   end
-  
+
   private
-  
+
   def aggregate
-    Librato::Rails.aggregate
+    collector.aggregate
   end
-  
+
+  def collector
+    Librato.tracker.collector
+  end
+
   def counters
-    Librato::Rails.counters
+    collector.counters
   end
 end