librato-rack 0.1.0

data/test/test_helper.rb

@@ -0,0 +1,22 @@
+require 'bundler'
+Bundler.setup
+
+require 'pry'
+require 'minitest/autorun'
+# require 'mocha/setup'
+
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+
+require 'librato/rack'
+
+# require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+# require "rails/test_help"
+
+# Configure capybara
+# require 'capybara/rails'
+# Capybara.default_driver = :rack_test
+# Capybara.default_selector = :css
+
+# Load support files
+#Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

data/test/unit/collector/aggregator_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+module Librato
+  class Collector
+    class AggregatorTest < MiniTest::Unit::TestCase
+
+      def setup
+        @agg = 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
+
+      def test_flush
+        @agg.measure 'meaning.of.life', 1
+        @agg.measure 'meaning.of.life', 42, :source => 'douglas_adams'
+
+        q = Librato::Metrics::Queue.new
+        @agg.flush_to(q)
+        expected = Set.new([
+          {:name=>"meaning.of.life", :count=>1, :sum=>1.0, :min=>1.0, :max=>1.0},
+          {:name=>"meaning.of.life", :count=>1, :sum=>42.0, :min=>42.0, :max=>42.0, :source=>"douglas_adams"}])
+        assert_equal expected, Set.new(q.queued[:gauges])
+      end
+
+    end
+  end
+end

data/test/unit/collector/counter_cache_test.rb

@@ -0,0 +1,96 @@
+require 'test_helper'
+
+module Librato
+  class Collector
+    class CounterCacheTest < MiniTest::Unit::TestCase
+
+      def test_basic_operations
+        cc = 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 = 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_sporadic
+        cc = 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)
+
+        # persist values once
+        cc.flush_to(Librato::Metrics::Queue.new)
+
+        # normal values persist
+        assert_equal 0, cc[:foo]
+        assert_equal 0, cc.fetch(:foo, :source => 'bar')
+
+        # sporadic 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]
+
+        # persist values again
+        cc.flush_to(Librato::Metrics::Queue.new)
+        assert_equal nil, cc[:bazoom]
+      end
+
+      def test_flushing
+        cc = 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
+  end
+end

data/test/unit/collector/group_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+module Librato
+  class Collector
+    class GroupTest < MiniTest::Unit::TestCase
+
+      def test_increment
+        collector = Collector.new
+        collector.group 'foo' do |g|
+          g.increment :bar
+        end
+        assert_equal 1, collector.counters['foo.bar']
+      end
+
+      def test_measure
+        collector = Collector.new
+        collector.group 'foo' do |g|
+          g.measure :baz, 23
+        end
+        assert_equal 23, collector.aggregate['foo.baz'][:sum]
+      end
+
+      def test_timing
+        collector = Collector.new
+        collector.group 'foo' do |g|
+          g.timing :bam, 32.0
+        end
+        assert_equal 32.0, collector.aggregate['foo.bam'][:sum]
+      end
+
+      def test_timing_block
+        collector = Collector.new
+        collector.group 'foo' do |g|
+          g.timing :bak do
+            sleep 0.01
+          end
+        end
+        assert_in_delta 10.0, collector.aggregate['foo.bak'][:sum], 2
+      end
+
+      def test_nesting
+        collector = Collector.new
+        collector.group 'foo' do |g|
+          g.group :bar do |b|
+            b.increment :baz, 2
+          end
+        end
+        assert_equal 2, collector.counters['foo.bar.baz']
+      end
+
+    end
+  end
+end

data/test/unit/collector_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+module Librato
+  class CollectorTest < MiniTest::Unit::TestCase
+
+    def test_proxy_object_access
+      collector = Collector.new
+      assert collector.aggregate, 'should have aggregate object'
+      assert collector.counters, 'should have counter object'
+    end
+
+    def test_basic_grouping
+      collector = Collector.new
+      collector.group 'foo' do |g|
+        g.increment :bar
+        g.measure :baz, 23
+      end
+      assert_equal 1, collector.counters['foo.bar']
+      assert_equal 23, collector.aggregate['foo.baz'][:sum]
+    end
+
+  end
+end

data/test/unit/rack/configuration_test.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+
+module Librato
+  class Rack
+    class ConfigurationTest < MiniTest::Unit::TestCase
+
+      def setup
+        clear_env_vars
+      end
+
+      def teardown
+        clear_env_vars
+      end
+
+      def test_defaults
+        config = Configuration.new
+        assert_equal 60, config.flush_interval
+        assert_equal Librato::Metrics.api_endpoint, config.api_endpoint
+      end
+
+      def test_environment_variable_config
+        ENV['LIBRATO_USER'] = 'foo@bar.com'
+        ENV['LIBRATO_TOKEN'] = 'api_key'
+        ENV['LIBRATO_SOURCE'] = 'source'
+        config = Configuration.new
+        assert_equal 'foo@bar.com', config.user
+        assert_equal 'api_key', config.token
+        assert_equal 'source', config.source
+        #assert Librato::Rails.explicit_source, 'source is explicit'
+      end
+
+      def test_legacy_env_variable_config
+        ENV['LIBRATO_METRICS_USER'] = 'foo@bar.com'
+        ENV['LIBRATO_METRICS_TOKEN'] = 'api_key'
+        ENV['LIBRATO_METRICS_SOURCE'] = 'source'
+        config = Configuration.new
+        assert_equal 'foo@bar.com', config.user
+        assert_equal 'api_key', config.token
+        assert_equal 'source', config.source
+        # assert Librato::Rails.explicit_source, 'source is explicit'
+      end
+
+      def test_explicit_source
+        config = Configuration.new
+        assert !config.explicit_source?
+        config.source = 'tessaract'
+        assert config.explicit_source?
+        config.source = nil
+        assert !config.explicit_source?, 'source should no long be explicit when reset'
+      end
+
+      def test_prefix_change_notification
+        config = Configuration.new
+        listener = listener_object
+        config.register_listener(listener)
+        config.prefix = 'newfoo'
+        assert_equal 'newfoo', listener.prefix
+      end
+
+      private
+
+      def clear_env_vars
+        ENV.delete('LIBRATO_USER')
+        ENV.delete('LIBRATO_TOKEN')
+        ENV.delete('LIBRATO_SOURCE')
+        ENV.delete('LIBRATO_LOG_LEVEL')
+        # legacy
+        ENV.delete('LIBRATO_METRICS_USER')
+        ENV.delete('LIBRATO_METRICS_TOKEN')
+        ENV.delete('LIBRATO_METRICS_SOURCE')
+      end
+
+      def listener_object
+        listener = Object.new
+        def listener.prefix=(prefix)
+          @prefix = prefix
+        end
+        def listener.prefix
+          @prefix
+        end
+        listener
+      end
+
+    end
+  end
+end

data/test/unit/rack/logger_test.rb

@@ -0,0 +1,91 @@
+require 'test_helper'
+require 'stringio'
+
+module Librato
+  class Rack
+    class LoggerTest < MiniTest::Unit::TestCase
+
+      def setup
+        @buffer = StringIO.new
+        #log_object = ::Logger.new(@buffer) # stdlib logger
+        @logger = Logger.new(@buffer) # rack logger
+      end
+
+      def test_log_levels
+        assert_equal :info, @logger.log_level, 'should default to info'
+
+        @logger.log_level = :debug
+        assert_equal :debug, @logger.log_level, 'should accept symbols'
+
+        @logger.log_level = 'trace'
+        assert_equal :trace, @logger.log_level, 'should accept strings'
+
+        assert_raises(InvalidLogLevel) { @logger.log_level = :foo }
+      end
+
+      def test_simple_logging
+        @logger.log_level = :info
+
+        # logging at log level
+        @logger.log :info, 'a log message'
+        assert_equal 1, buffer_lines.length, 'should have added a line'
+        assert buffer_lines[0].index('a log message'), 'should log message'
+
+        # logging above level
+        @logger.log :error, 'an error message'
+        assert_equal 2, buffer_lines.length, 'should have added a line'
+        assert buffer_lines[1].index('an error message'), 'should log message'
+
+        # logging below level
+        @logger.log :debug, 'a debug message'
+        assert_equal 2, buffer_lines.length, 'should not have added a line'
+      end
+
+      def test_logging_through_stdlib_logger_object
+        stdlib_logger = ::Logger.new(@buffer)
+        @logger = Logger.new(stdlib_logger)
+
+        @logger.log_level = :info
+
+        # logging at log level
+        @logger.log :info, 'a log message'
+        assert_equal 1, buffer_lines.length, 'should have added a line'
+        assert buffer_lines[0].index('a log message'), 'should log message'
+
+        # logging above level
+        @logger.log :error, 'an error message'
+        assert_equal 2, buffer_lines.length, 'should have added a line'
+        assert buffer_lines[1].index('an error message'), 'should log message'
+
+        # logging below level
+        @logger.log :debug, 'a debug message'
+        assert_equal 2, buffer_lines.length, 'should not have added a line'
+      end
+
+      def test_block_logging
+        @logger.log_level = :info
+
+        # logging at log level
+        @logger.log(:info) { "log statement" }
+        assert_equal 1, buffer_lines.length, 'should have added a line'
+        assert buffer_lines[0].index('log statement'), 'should log message'
+      end
+
+      def test_log_prefix
+        assert_equal '[librato-rack] ', @logger.prefix
+
+        @logger.prefix = '[test prefix] '
+        @logger.log :error, 'an error message'
+        assert buffer_lines[0].index('[test prefix] '), 'should use prefix'
+      end
+
+      private
+
+      def buffer_lines
+        @buffer.rewind
+        @buffer.readlines
+      end
+
+    end
+  end
+end