librato-rails 0.9.0 → 0.10.0.pre1

data/lib/librato/rails/group.rb

@@ -1,27 +0,0 @@
-module Librato
-  module Rails
-    class Group
-
-      def initialize(prefix)
-        @prefix = "#{prefix}."
-      end
-
-      def group(prefix)
-        prefix = "#{@prefix}#{prefix}"
-        yield self.class.new(prefix)
-      end
-
-      def increment(counter, by=1)
-        counter = "#{@prefix}#{counter}"
-        Librato::Rails.increment counter, by
-      end
-
-      def measure(event, duration)
-        event = "#{@prefix}#{event}"
-        Librato::Rails.measure event, duration
-      end
-      alias :timing :measure
-
-    end
-  end
-end

data/lib/librato/rails/logging.rb

@@ -1,77 +0,0 @@
-module Librato::Rails
-  module Logging
-    LOG_LEVELS = [:off, :error, :warn, :info, :debug, :trace]
-
-    attr_writer :logger
-
-    # ex: log :debug, 'this is a debug message'
-    def log(level, message)
-      return unless should_log?(level)
-      case level
-      when :error, :warn
-        method = level
-      else
-        method = :info
-      end
-      message = '[librato-rails] ' << message
-      logger.send(method, message)
-    end
-
-    # set log level to any of LOG_LEVELS
-    def log_level=(level)
-      level = level.to_sym
-      if LOG_LEVELS.index(level)
-        @log_level = level
-        require 'pp' if should_log?(:debug)
-      else
-        raise "Invalid log level '#{level}'"
-      end
-    end
-
-    def log_level
-      @log_level ||= :info
-    end
-
-    def logger
-      @logger ||= if on_heroku
-        logger = Logger.new(STDOUT)
-        logger.level = Logger::INFO
-        logger
-      else
-        ::Rails.logger
-      end
-    end
-
-    private
-
-    def should_log?(level)
-      LOG_LEVELS.index(self.log_level) >= LOG_LEVELS.index(level)
-    end
-
-    # trace current environment
-    def trace_environment
-      log :info, "Environment: " + ENV.pretty_inspect
-    end
-
-    # trace metrics being sent
-    def trace_queued(queued)
-      log :trace, "Queued: " + queued.pretty_inspect
-    end
-
-    def trace_settings
-      settings = {
-        :user => self.user,
-        :token => self.token,
-        :source => source,
-        :explicit_source => self.explicit_source ? 'true' : 'false',
-        :source_pids => self.source_pids ? 'true' : 'false',
-        :qualified_source => qualified_source,
-        :log_level => log_level,
-        :prefix => prefix,
-        :flush_interval => self.flush_interval
-      }
-      log :info, 'Settings: ' + settings.pretty_inspect
-    end
-
-  end
-end

data/lib/librato/rails/validating_queue.rb

@@ -1,31 +0,0 @@
-# this functionality should probably be available in librato-metrics
-# eventually, spiking here for now to work out the kinks
-module Librato
-  module Rails
-    class ValidatingQueue < Librato::Metrics::Queue
-      LOGGER = Librato::Rails
-      METRIC_NAME_REGEX = /\A[-.:_\w]{1,255}\z/
-      SOURCE_NAME_REGEX = /\A[-:A-Za-z0-9_.]{1,255}\z/
-
-      # screen all measurements for validity before sending
-      def submit
-        @queued[:gauges].delete_if do |entry|
-          name = entry[:name].to_s
-          source = entry[:source] && entry[:source].to_s
-          if name !~ METRIC_NAME_REGEX
-            LOGGER.log :warn, "invalid metric name '#{name}', not sending."
-            true # delete
-          elsif source && source !~ SOURCE_NAME_REGEX
-            LOGGER.log :warn, "invalid source name '#{source}', not sending."
-            true # delete
-          else
-            false # preserve
-          end
-        end
-
-        super
-      end
-
-    end
-  end
-end

data/lib/librato/rails/worker.rb

@@ -1,54 +0,0 @@
-module Librato
-  module Rails
-
-    # This class manages the background thread which submits all data
-    # to the Librato Metrics service.
-    class Worker
-
-      def initialize
-        @interrupt = false
-      end
-
-      # do the assigned work, catching some special cases
-      #
-      def execute(obj)
-        obj.call
-      end
-
-      # run the given block every <period> seconds, looping
-      # infinitely unless @interrupt becomes true.
-      #
-      def run_periodically(period, &block)
-        next_run = start_time(period)
-        until @interrupt do
-          now = Time.now
-          if now >= next_run
-            execute(block) # runs given block
-            while next_run <= now
-              next_run += period
-            end
-          else
-            sleep(next_run - now)
-          end
-        end
-      end
-
-      # Give some structure to worker start times so when possible
-      # they will be in sync.
-      def start_time(period)
-        earliest = Time.now + period
-        # already on a whole minute
-        return earliest if earliest.sec == 0
-        if period > 30
-          # bump to whole minute
-          earliest + (60-earliest.sec)
-        else
-          # ensure sync to whole minute if minute is evenly divisible
-          earliest + (period-(earliest.sec%period))
-        end
-      end
-
-    end
-
-  end
-end

data/lib/tasks/metrics-rails_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :librato-rails do
-#   # Task goes here
-# end

data/test/librato-rails_test.rb

@@ -1,44 +0,0 @@
-require 'test_helper'
-
-class LibratoRailsTest < ActiveSupport::TestCase
-  
-  test 'is a module' do
-    assert_kind_of Module, Librato::Rails
-  end
-  
-  test 'client is available' do
-    assert_kind_of Librato::Metrics::Client, Librato::Rails.client
-  end
-  
-  test '#increment exists' do
-    assert Librato::Rails.respond_to?(:increment)
-    Librato::Rails.increment :baz, 5
-  end
-  
-  test '#measure exists' do
-    assert Librato::Rails.respond_to?(:measure)
-    Librato::Rails.measure 'queries', 10
-  end
-  
-  test '#timing exists' do
-    assert Librato::Rails.respond_to?(:timing)
-    Librato::Rails.timing 'request.time.total', 121.2
-  end
-  
-  test 'source is assignable' do
-    original = Librato::Rails.source
-    Librato::Rails.source = 'foobar'
-    assert_equal 'foobar', Librato::Rails.source
-    Librato::Rails.source = original
-  end
-  
-  test 'qualified source includes pid' do
-    assert_match /\.\d{2,6}$/, Librato::Rails.qualified_source
-  end
-  
-  test 'qualified source does not include pid when disabled' do
-    Librato::Rails.source_pids = false
-    assert_match Librato::Rails.source, Librato::Rails.qualified_source
-    Librato::Rails.source_pids = true
-  end
-end

data/test/remote/rails_remote_test.rb

@@ -1,193 +0,0 @@
-# encoding: UTF-8
-require 'test_helper'
-
-class LibratoRailsRemoteTest < ActiveSupport::TestCase
-
-  # These tests connect to the Metrics server with an account and verify remote
-  # functions. They will only run if the below environment variables are set.
-  #
-  # BE CAREFUL, running these tests will DELETE ALL metrics currently in the
-  # test account.
-  #
-  if ENV['LIBRATO_RAILS_TEST_EMAIL'] && ENV['LIBRATO_RAILS_TEST_API_KEY']
-
-    setup do
-      # delete any generated Librato::Rails
-      Librato::Rails.user = ENV['LIBRATO_RAILS_TEST_EMAIL']
-      Librato::Rails.token = ENV['LIBRATO_RAILS_TEST_API_KEY']
-      if ENV['LIBRATO_RAILS_TEST_API_ENDPOINT']
-        Librato::Rails.api_endpoint = ENV['LIBRATO_RAILS_TEST_API_ENDPOINT']
-      end
-      Librato::Rails.delete_all
-      delete_all_metrics
-    end
-
-    teardown do
-      Librato::Rails.prefix = nil
-    end
-
-    test 'flush sends counters' do
-      source = Librato::Rails.qualified_source
-
-      Librato::Rails.increment :foo
-      Librato::Rails.increment :bar, 2
-      Librato::Rails.increment :foo
-      Librato::Rails.increment :foo, :source => 'baz', :by => 3
-      Librato::Rails.flush
-
-      client = Librato::Rails.client
-      metric_names = client.list.map { |m| m['name'] }
-      assert metric_names.include?('foo'), 'foo should be present'
-      assert metric_names.include?('bar'), 'bar should be present'
-
-      foo = client.fetch 'foo', :count => 10
-      assert_equal 1, foo[source].length
-      assert_equal 2, foo[source][0]['value']
-
-      # custom source
-      assert_equal 1, foo['baz'].length
-      assert_equal 3, foo['baz'][0]['value']
-
-      bar = client.fetch 'bar', :count => 10
-      assert_equal 1, bar[source].length
-      assert_equal 2, bar[source][0]['value']
-    end
-
-    test 'counters should persist through flush' do
-      Librato::Rails.increment 'knightrider'
-      Librato::Rails.increment 'badguys', :sporadic => true
-      assert_equal 1, Librato::Rails.counters['knightrider']
-      assert_equal 1, Librato::Rails.counters['badguys']
-
-      Librato::Rails.flush
-      assert_equal 0, Librato::Rails.counters['knightrider']
-      assert_equal nil, Librato::Rails.counters['badguys']
-    end
-
-    test 'flush sends measures/timings' do
-      source = Librato::Rails.qualified_source
-
-      Librato::Rails.timing  'request.time.total', 122.1
-      Librato::Rails.measure 'items_bought', 20
-      Librato::Rails.timing  'request.time.total', 81.3
-      Librato::Rails.timing  'jobs.queued', 5, :source => 'worker.3'
-      Librato::Rails.flush
-
-      client = Librato::Rails.client
-      metric_names = client.list.map { |m| m['name'] }
-      assert metric_names.include?('request.time.total'), 'request.time.total should be present'
-      assert metric_names.include?('items_bought'), 'request.time.db should be present'
-
-      total = client.fetch 'request.time.total', :count => 10
-      assert_equal 2, total[source][0]['count']
-      assert_in_delta 203.4, total[source][0]['sum'], 0.1
-
-      items = client.fetch 'items_bought', :count => 10
-      assert_equal 1, items[source][0]['count']
-      assert_in_delta 20, items[source][0]['sum'], 0.1
-
-      jobs = client.fetch 'jobs.queued', :count => 10
-      assert_equal 1, jobs['worker.3'][0]['count']
-      assert_in_delta 5, jobs['worker.3'][0]['sum'], 0.1
-    end
-
-    test 'flush should purge measures/timings' do
-      Librato::Rails.timing  'request.time.total', 122.1
-      Librato::Rails.measure 'items_bought', 20
-      Librato::Rails.flush
-
-      assert Librato::Rails.aggregate.empty?, 'measures and timings should be cleared with flush'
-    end
-
-    test 'empty flush should not be sent' do
-      Librato::Rails.flush
-      assert_equal [], Librato::Rails.client.list
-    end
-
-    test 'flush respects prefix' do
-      source = Librato::Rails.qualified_source
-      Librato::Rails.prefix = 'testyprefix'
-
-      Librato::Rails.timing 'mytime', 221.1
-      Librato::Rails.increment 'mycount', 4
-      Librato::Rails.flush
-
-      client = Librato::Rails.client
-      metric_names = client.list.map { |m| m['name'] }
-      assert metric_names.include?('testyprefix.mytime'), 'testyprefix.mytime should be present'
-      assert metric_names.include?('testyprefix.mycount'), 'testyprefix.mycount should be present'
-
-      mytime = client.fetch 'testyprefix.mytime', :count => 10
-      assert_equal 1, mytime[source][0]['count']
-
-      mycount = client.fetch 'testyprefix.mycount', :count => 10
-      assert_equal 4, mycount[source][0]['value']
-    end
-
-    test 'flush recovers from failed flush' do
-      client = Librato::Rails.client
-      source = Librato::Rails.qualified_source
-
-      # create a metric foo of counter type
-      client.submit :foo => {:type => :counter, :value => 12}
-
-      # failing flush - submit a foo measurement as a gauge (type mismatch)
-      Librato::Rails.measure :foo, 2.12
-      Librato::Rails.flush
-
-      foo = client.fetch :foo, :count => 10
-      assert_equal 1, foo['unassigned'].length
-      assert_nil foo[source] # shouldn't have been accepted
-
-      Librato::Rails.measure :boo, 2.12
-      Librato::Rails.flush
-
-      boo = client.fetch :boo, :count => 10
-      assert_equal 2.12, boo[source][0]["value"]
-    end
-
-    test 'flush tolerates invalid metric names' do
-      client = Librato::Rails.client
-      source = Librato::Rails.qualified_source
-
-      Librato::Rails.increment :foo
-      Librato::Rails.increment 'fübar'
-      Librato::Rails.measure 'fu/bar/baz', 12.1
-      Librato::Rails.flush
-
-      metric_names = client.list.map { |m| m['name'] }
-      assert metric_names.include?('foo')
-
-      # should have saved values for foo even though
-      # other metrics had invalid names
-      foo = client.fetch :foo, :count => 5
-      assert_equal 1.0, foo[source][0]["value"]
-    end
-
-    test 'flush tolerates invalid source names' do
-      client = Librato::Rails.client
-
-      Librato::Rails.increment :foo, :source => 'atreides'
-      Librato::Rails.increment :bar, :source => 'glébnöst'
-      Librato::Rails.measure 'baz', 2.25, :source => 'b/l/ak/nok'
-      Librato::Rails.flush
-
-      # should have saved values for foo even though
-      # other metrics had invalid sources
-      foo = client.fetch :foo, :count => 5
-      assert_equal 1.0, foo['atreides'][0]["value"]
-    end
-
-    private
-
-    def delete_all_metrics
-      client = Librato::Rails.client
-      metric_names = client.list.map { |metric| metric['name'] }
-      client.delete(*metric_names) if !metric_names.empty?
-    end
-
-  else
-    puts "Skipping remote tests..."
-  end
-
-end

data/test/unit/aggregator_test.rb

@@ -1,53 +0,0 @@
-require 'test_helper'
-
-class LibratoRailsAggregatorTest < MiniTest::Unit::TestCase
-  
-  def setup
-    @agg = Librato::Rails::Aggregator.new
-  end
-  
-  def test_adding_timings
-    @agg.timing 'request.time.total', 23.7
-    @agg.timing 'request.time.db', 5.3
-    @agg.timing 'request.time.total', 64.3
-    
-    assert_equal 2, @agg['request.time.total'][:count]
-    assert_equal 88.0, @agg['request.time.total'][:sum]
-  end
-  
-  def test_block_timing
-    @agg.timing 'my.task' do
-      sleep 0.2
-    end
-    assert_in_delta @agg['my.task'][:sum], 200, 50
-    
-    @agg.timing('another.task') { sleep 0.1 }
-    assert_in_delta @agg['another.task'][:sum], 100, 50
-  end
-  
-  def test_return_values
-    simple = @agg.timing 'simple', 20
-    assert_equal nil, simple
-    
-    timing = @agg.timing 'foo' do
-      sleep 0.1
-      'bar'
-    end
-    assert_equal 'bar', timing
-  end
-  
-  def test_custom_source
-    # sources are kept separate
-    @agg.measure 'meaning.of.life', 1
-    @agg.measure 'meaning.of.life', 42, :source => 'douglas_adams'
-    assert_equal 1.0, @agg.fetch('meaning.of.life')[:sum]
-    assert_equal 42.0, @agg.fetch('meaning.of.life', :source => 'douglas_adams')[:sum]
-    
-    # sources work with time blocks
-    @agg.timing 'mytiming', :source => 'mine' do
-      sleep 0.02
-    end
-    assert_in_delta @agg.fetch('mytiming', :source => 'mine')[:sum], 20, 10
-  end
-  
-end

data/test/unit/counter_cache_test.rb

@@ -1,90 +0,0 @@
-require 'test_helper'
-
-class LibratoRailsCounterCacheTest < MiniTest::Unit::TestCase
-  
-  def test_basic_operations
-    cc = Librato::Rails::CounterCache.new
-    cc.increment :foo
-    assert_equal 1, cc[:foo]
-    
-    # accepts optional argument
-    cc.increment :foo, :by => 5
-    assert_equal 6, cc[:foo]
-    
-    # legacy style
-    cc.increment :foo, 2
-    assert_equal 8, cc[:foo]
-    
-    # strings or symbols work
-    cc.increment 'foo'
-    assert_equal 9, cc['foo']
-  end
-  
-  def test_custom_sources
-    cc = Librato::Rails::CounterCache.new
-    
-    cc.increment :foo, :source => 'bar'
-    assert_equal 1, cc.fetch(:foo, :source => 'bar')
-    
-    # symbols also work
-    cc.increment :foo, :source => :baz
-    assert_equal 1, cc.fetch(:foo, :source => :baz)
-    
-    # strings and symbols are interchangable
-    cc.increment :foo, :source => :bar
-    assert_equal 2, cc.fetch(:foo, :source => 'bar')
-     
-    # custom source and custom increment
-    cc.increment :foo, :source => 'boombah', :by => 10
-    assert_equal 10, cc.fetch(:foo, :source => 'boombah')
-  end
-  
-  def test_continuous
-    cc = Librato::Rails::CounterCache.new
-    
-    cc.increment :foo
-    cc.increment :foo, :source => 'bar'
-    
-    cc.increment :baz, :sporadic => true
-    cc.increment :baz, :source => 118, :sporadic => true
-    assert_equal 1, cc[:baz]
-    assert_equal 1, cc.fetch(:baz, :source => 118)
-    
-    cc.flush_to(Librato::Metrics::Queue.new) # persist values once
-    
-    # continous values persist
-    assert_equal 0, cc[:foo]
-    assert_equal 0, cc.fetch(:foo, :source => 'bar')
-    
-    # non-continous do not
-    assert_equal nil, cc[:baz]
-    assert_equal nil, cc.fetch(:baz, :source => 118)
-    
-    # add a different sporadic metric 
-    cc.increment :bazoom, :sporadic => true
-    assert_equal 1, cc[:bazoom]
-    
-    cc.flush_to(Librato::Metrics::Queue.new) # persist values again
-    assert_equal nil, cc[:bazoom]
-  end
-  
-  def test_flushing
-    cc = Librato::Rails::CounterCache.new
-    
-    cc.increment :foo
-    cc.increment :bar, :by => 2
-    cc.increment :foo, :source => 'foobar'
-    cc.increment :foo, :source => 'foobar', :by => 3
-    
-    q = Librato::Metrics::Queue.new
-    cc.flush_to(q)
-    
-    expected = Set.new [{:name=>"foo", :value=>1},
-                {:name=>"foo", :value=>4, :source=>"foobar"},
-                {:name=>"bar", :value=>2}]
-    queued = Set.new q.gauges
-    queued.each { |hash| hash.delete(:measure_time) } 
-    assert_equal queued, expected
-  end
-  
-end

data/test/unit/group_test.rb

@@ -1,54 +0,0 @@
-require 'test_helper'
-
-class LibratoRailsGroupTest < MiniTest::Unit::TestCase
-  
-  def test_basic_grouping
-    Librato::Rails.group 'fruit' do |g|
-      g.increment 'bites'
-      g.increment 'nibbles', :by => 2
-      g.increment 'nibbles', 5
-      
-      g.increment 'chomps', :source => 'pacman'
-      g.increment 'chomps', :source => 'pacman', :by => 5
-      
-      g.measure 'banana', 12
-      g.measure 'banana', 10
-      
-      g.timing 'grow_time', 122.2
-      g.timing 'grow_time', 24.3
-    end
-    
-    assert_equal 1, counters['fruit.bites']
-    assert_equal 7, counters['fruit.nibbles']
-    assert_equal 6, counters.fetch('fruit.chomps', :source => 'pacman')
-
-    assert_equal 2, aggregate['fruit.banana'][:count]
-    assert_equal 22, aggregate['fruit.banana'][:sum]
-    
-    assert_equal 2, aggregate['fruit.grow_time'][:count]
-    assert_equal 146.5, aggregate['fruit.grow_time'][:sum]
-  end
-  
-  def test_nesting
-    Librato::Rails.group 'street' do |s|
-      s.increment 'count'
-      s.group 'market' do |m|
-        m.increment 'tenants', 10
-      end
-    end
-    
-    assert_equal 1, counters['street.count']
-    assert_equal 10, counters['street.market.tenants']
-  end
-  
-  private
-  
-  def aggregate
-    Librato::Rails.aggregate
-  end
-  
-  def counters
-    Librato::Rails.counters
-  end
-  
-end