librato-rack 0.1.0

data/lib/librato/rack/version.rb

@@ -0,0 +1,5 @@
+module Librato
+  class Rack
+    VERSION = "0.1.0"
+  end
+end

data/lib/librato/rack/worker.rb

@@ -0,0 +1,49 @@
+module Librato
+  class Rack
+    # Runs a given piece of code periodically, ensuring that
+    # it will be run again at the proper interval regardless
+    # of how long execution takes.
+    #
+    class Worker
+
+      def initialize
+        @interrupt = false
+      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
+            block.call
+            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/test/apps/basic.ru

@@ -0,0 +1,20 @@
+require 'bundler/setup'
+require 'librato-rack'
+
+use Librato::Rack
+
+def application(env)
+  case env['PATH_INFO']
+  when '/status/204'
+    [204, {"Content-Type" => 'text/html'}, ["Status 204!"]]
+  when '/exception'
+    raise 'exception raised!'
+  when '/slow'
+    sleep 0.3
+    [200, {"Content-Type" => 'text/html'}, ["Slow request"]]
+  else
+    [200, {"Content-Type" => 'text/html'}, ["Hello!"]]
+  end
+end
+
+run method(:application)

data/test/apps/custom.ru

@@ -0,0 +1,27 @@
+require 'bundler/setup'
+require 'librato-rack'
+
+use Librato::Rack
+
+def application(env)
+  case env['PATH_INFO']
+  when '/increment'
+    Librato.increment :hits
+  when '/measure'
+    Librato.measure 'nodes', 3
+  when '/timing'
+    Librato.timing 'lookup.time', 2.3
+  when '/timing_block'
+    Librato.timing 'sleeper' do
+      sleep 0.01
+    end
+  when '/group'
+    Librato.group 'did.a' do |g|
+      g.increment 'thing'
+      g.timing 'timing', 2.3
+    end
+  end
+  [200, {"Content-Type" => 'text/html'}, ["Hello!"]]
+end
+
+run method(:application)

data/test/apps/heroku.ru

@@ -0,0 +1,27 @@
+require 'bundler/setup'
+require 'librato-rack'
+
+# Simulate the environment variables Heroku passes along
+# with each request
+#
+class FakeHeroku
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    env['HTTP_X_HEROKU_QUEUE_DEPTH'] = rand(4)
+    env['HTTP_X_HEROKU_QUEUE_WAIT_TIME'] = rand(0.1)
+    env['HTTP_X_HEROKU_DYNOS_IN_USE'] = 2
+    @app.call(env)
+  end
+end
+
+use FakeHeroku
+use Librato::Rack
+
+def application(env)
+  [200, {"Content-Type" => 'text/html'}, ["Hello!"]]
+end
+
+run method(:application)

data/test/integration/custom_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+require 'rack/test'
+
+# Tests for universal tracking for all request paths
+#
+class CustomTest < MiniTest::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    Rack::Builder.parse_file('test/apps/custom.ru').first
+  end
+
+  def teardown
+    # clear metrics before each run
+    aggregate.delete_all
+    counters.delete_all
+  end
+
+  def test_increment
+    get '/increment'
+    assert_equal 1, counters[:hits]
+    2.times { get '/increment' }
+    assert_equal 3, counters[:hits]
+  end
+
+  def test_measure
+    get '/measure'
+    assert_equal 3.0, aggregate[:nodes][:sum]
+    assert_equal 1, aggregate[:nodes][:count]
+  end
+
+  def test_timing
+    get '/timing'
+    assert_equal 1, aggregate['lookup.time'][:count]
+  end
+
+  def test_timing_block
+    get '/timing_block'
+    assert_equal 1, aggregate['sleeper'][:count]
+    assert_in_delta 10, aggregate['sleeper'][:sum], 10
+  end
+
+  def test_grouping
+    get '/group'
+    assert_equal 1, counters['did.a.thing']
+    assert_equal 1, aggregate['did.a.timing'][:count]
+  end
+
+  private
+
+  def aggregate
+    Librato.tracker.collector.aggregate
+  end
+
+  def counters
+    Librato.tracker.collector.counters
+  end
+
+end

data/test/integration/heroku_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+require 'rack/test'
+
+# Tests for universal tracking for all request paths
+#
+class HerokuTest < MiniTest::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    Rack::Builder.parse_file('test/apps/heroku.ru').first
+  end
+
+  def teardown
+    # clear metrics before each run
+    aggregate.delete_all
+    counters.delete_all
+  end
+
+  def test_heroku_metrics
+    get '/'
+    assert_equal 1, aggregate['rack.heroku.queue.depth'][:count]
+    assert_equal 1, aggregate['rack.heroku.queue.wait_time'][:count]
+    assert_equal 1, aggregate['rack.heroku.dynos'][:count]
+  end
+
+  private
+
+  def aggregate
+    Librato.tracker.collector.aggregate
+  end
+
+  def counters
+    Librato.tracker.collector.counters
+  end
+
+end

data/test/integration/request_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+require 'rack/test'
+
+# Tests for universal tracking for all request paths
+#
+class RequestTest < MiniTest::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    Rack::Builder.parse_file('test/apps/basic.ru').first
+  end
+
+  def teardown
+    # clear metrics before each run
+    aggregate.delete_all
+    counters.delete_all
+  end
+
+  def test_increment_total_and_status
+    get '/'
+    assert last_response.ok?
+    assert_equal 1, counters["rack.request.total"]
+    assert_equal 1, counters["rack.request.status.200"]
+    assert_equal 1, counters["rack.request.status.2xx"]
+
+    get '/status/204'
+    assert_equal 2, counters["rack.request.total"]
+    assert_equal 1, counters["rack.request.status.200"], 'should not increment'
+    assert_equal 1, counters["rack.request.status.204"], 'should increment'
+    assert_equal 2, counters["rack.request.status.2xx"]
+  end
+
+  def test_request_times
+    get '/'
+
+    # common for all paths
+    assert_equal 1, aggregate["rack.request.time"][:count],
+      'should track total request time'
+
+    # status specific
+    assert_equal 1, aggregate["rack.request.status.200.time"][:count]
+    assert_equal 1, aggregate["rack.request.status.2xx.time"][:count]
+  end
+
+  def test_track_exceptions
+    begin
+      get '/exception'
+    rescue RuntimeError => e
+      raise unless e.message == 'exception raised!'
+    end
+    assert_equal 1, counters["rack.request.exceptions"]
+  end
+
+  def test_track_slow_requests
+    get '/slow'
+    assert_equal 1, counters["rack.request.slow"]
+  end
+
+  private
+
+  def aggregate
+    Librato.tracker.collector.aggregate
+  end
+
+  def counters
+    Librato.tracker.collector.counters
+  end
+
+end

data/test/remote/tracker_test.rb

@@ -0,0 +1,198 @@
+# # encoding: UTF-8
+require 'test_helper'
+require 'rack/test'
+
+# Tests for universal tracking for all request paths
+#
+class TrackerRemoteTest < MiniTest::Unit::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_RACK_TEST_EMAIL'] && ENV['LIBRATO_RACK_TEST_API_KEY']
+
+    def setup
+      config = Librato::Rack::Configuration.new
+      config.user = ENV['LIBRATO_RACK_TEST_EMAIL']
+      config.token = ENV['LIBRATO_RACK_TEST_API_KEY']
+      if ENV['LIBRATO_RACK_TEST_API_ENDPOINT']
+        config.api_endpoint = ENV['LIBRATO_RACK_TEST_API_ENDPOINT']
+      end
+      config.log_target = File.open('/dev/null', 'w') # ignore logs
+      @tracker = Librato::Rack::Tracker.new(config)
+      delete_all_metrics
+    end
+
+    def test_flush_counters
+      tracker.increment :foo                              # simple
+      tracker.increment :bar, 2                           # specified
+      tracker.increment :foo                              # multincrement
+      tracker.increment :foo, :source => 'baz', :by => 3  # custom source
+      tracker.flush
+
+      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
+
+    def test_counter_persistent_through_flush
+      tracker.increment 'knightrider'
+      tracker.increment 'badguys', :sporadic => true
+      assert_equal 1, collector.counters['knightrider']
+      assert_equal 1, collector.counters['badguys']
+
+      tracker.flush
+      assert_equal 0, collector.counters['knightrider']
+      assert_equal nil, collector.counters['badguys']
+    end
+
+    def test_flush_should_send_measures_and_timings
+      tracker.timing  'request.time.total', 122.1
+      tracker.measure 'items_bought', 20
+      tracker.timing  'request.time.total', 81.3
+      tracker.timing  'jobs.queued', 5, :source => 'worker.3'
+      tracker.flush
+
+      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
+
+    def test_flush_should_purge_measures_and_timings
+      tracker.timing  'request.time.total', 122.1
+      tracker.measure 'items_bought', 20
+      tracker.flush
+
+      assert collector.aggregate.empty?, 'measures and timings should be cleared with flush'
+    end
+
+    # Disabled for now because we always send a running process
+    # count at a minimum
+    #
+    # def test_empty_flush_should_not_be_sent
+    #   tracker.flush
+    #   assert_equal [], client.list
+    # end
+
+    def test_flush_respects_prefix
+      config.prefix = 'testyprefix'
+
+      tracker.timing 'mytime', 221.1
+      tracker.increment 'mycount', 4
+      tracker.flush
+
+      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
+
+    def test_flush_recovers_from_failure
+      # 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)
+      tracker.measure :foo, 2.12
+      tracker.flush
+
+      foo = client.fetch :foo, :count => 10
+      assert_equal 1, foo['unassigned'].length
+      assert_nil foo[source] # shouldn't have been accepted
+
+      tracker.measure :boo, 2.12
+      tracker.flush
+
+      boo = client.fetch :boo, :count => 10
+      assert_equal 2.12, boo[source][0]["value"]
+    end
+
+    def test_flush_handles_invalid_metric_names
+      tracker.increment :foo              # valid
+      tracker.increment 'fübar'           # invalid
+      tracker.measure 'fu/bar/baz', 12.1  # invalid
+      tracker.flush
+
+      metric_names = client.list.map { |m| m['name'] }
+      assert metric_names.include?('foo')
+
+      # should have saved values for foo
+      foo = client.fetch :foo, :count => 5
+      assert_equal 1.0, foo[source][0]["value"]
+    end
+
+    def test_flush_handles_invalid_sources_names
+      tracker.increment :foo, :source => 'atreides'         # valid
+      tracker.increment :bar, :source => 'glébnöst'         # invalid
+      tracker.measure 'baz', 2.25, :source => 'b/l/ak/nok'  # invalid
+      tracker.flush
+
+      # should have saved values for foo
+      foo = client.fetch :foo, :count => 5
+      assert_equal 1.0, foo['atreides'][0]["value"]
+    end
+
+    private
+
+    def tracker
+      @tracker
+    end
+
+    def client
+      @tracker.send(:client)
+    end
+
+    def collector
+      @tracker.collector
+    end
+
+    def config
+      @tracker.config
+    end
+
+    def source
+      @tracker.qualified_source
+    end
+
+    def delete_all_metrics
+      metric_names = client.list.map { |metric| metric['name'] }
+      client.delete(*metric_names) if !metric_names.empty?
+    end
+
+  else
+    # ENV vars not set
+    puts "Skipping remote tests..."
+  end
+
+end