librato-rack 1.1.1 → 2.0.0

data/test/unit/collector/aggregator_test.rb

@@ -5,7 +5,8 @@ module Librato
     class AggregatorTest < Minitest::Test
 
       def setup
-        @agg = Aggregator.new
+        @tags = { hostname: "metrics-web-stg-1" }
+        @agg = Aggregator.new(default_tags: @tags)
       end
 
       def test_adding_timings
@@ -32,17 +33,17 @@ module Librato
         [0.1, 0.2, 0.3].each do |val|
           @agg.timing 'a.sample.thing', val, percentile: 50
         end
-        assert_equal 0.2, @agg.fetch('a.sample.thing', percentile: 50),
-          'can calculate percentile'
+        assert_equal 0.2, @agg.fetch("a.sample.thing", percentile: 50, tags: @tags),
+          "can calculate percentile"
 
         # multiple percentiles
         [0.2, 0.35].each do |val|
           @agg.timing 'a.sample.thing', val, percentile: [80, 95]
         end
-        assert_equal 0.31, @agg.fetch('a.sample.thing', percentile: 65),
-          'can calculate another percentile simultaneously'
-        assert_equal 0.35, @agg.fetch('a.sample.thing', percentile: 95),
-          'can calculate another percentile simultaneously'
+        assert_equal 0.31, @agg.fetch("a.sample.thing", percentile: 65, tags: @tags),
+          "can calculate another percentile simultaneously"
+        assert_equal 0.35, @agg.fetch("a.sample.thing", percentile: 95, tags: @tags),
+          "can calculate another percentile simultaneously"
 
         # ensure storage is efficient: this is a little gross because we
         # have to inquire past the public interface, but important to verify
@@ -62,13 +63,13 @@ module Librato
         }
       end
 
-      def test_percentiles_with_source
+      def test_percentiles_with_tags
         Array(1..10).each do |val|
-          @agg.timing 'a.sample.thing', val, percentile: 50, source: 'foo'
+          @agg.timing "a.sample.thing", val, percentile: 50
         end
         assert_equal 5.5,
-          @agg.fetch('a.sample.thing', source: 'foo', percentile: 50),
-          'can calculate percentile with source'
+          @agg.fetch("a.sample.thing", tags: @tags, percentile: 50),
+          "can calculate percentile with tags"
       end
 
       # Todo: mult percentiles, block form, with source, invalid percentile
@@ -84,42 +85,51 @@ module Librato
         assert_equal 'bar', timing
       end
 
-      def test_custom_source
-        # sources are kept separate
+      def test_custom_tags
+        tags_1 = { hostname: "douglas_adams" }
+        # tags are kept separate
         @agg.measure 'meaning.of.life', 1
-        @agg.measure 'meaning.of.life', 42, :source => 'douglas_adams'
+        @agg.measure "meaning.of.life", 42, tags: tags_1
         assert_equal 1.0, @agg.fetch('meaning.of.life')[:sum]
-        assert_equal 42.0, @agg.fetch('meaning.of.life', :source => 'douglas_adams')[:sum]
+        assert_equal 42.0, @agg.fetch("meaning.of.life", tags: tags_1)[:sum]
 
-        # sources work with time blocks
-        @agg.timing 'mytiming', :source => 'mine' do
+        tags_2 = { hostname: "mine" }
+        # tags work with time blocks
+        @agg.timing "mytiming", tags: tags_2 do
           sleep 0.02
         end
-        assert_in_delta @agg.fetch('mytiming', :source => 'mine')[:sum], 20, 10
+        assert_in_delta @agg.fetch("mytiming", tags: tags_2)[:sum], 20, 10
+      end
+
+      def test_legacy_source
+        legacy_agg = Aggregator.new
+        legacy_agg.measure "feature_flag.check", 5, source: "new_feature"
+        assert_equal 5, legacy_agg.fetch("feature_flag.check", tags: { source: "new_feature" })[:sum]
       end
 
       def test_flush
+        tags = { hostname: "douglas_adams" }
         @agg.measure 'meaning.of.life', 1
-        @agg.measure 'meaning.of.life', 42, :source => 'douglas_adams'
+        @agg.measure "meaning.of.life", 42, tags: tags
 
         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"}
+          {:name=>"meaning.of.life", :count=>1, :sum=>1.0, :min=>1.0, :max=>1.0, :tags=>@tags},
+          {:name=>"meaning.of.life", :count=>1, :sum=>42.0, :min=>42.0, :max=>42.0, :tags=>tags}
         ])
-        assert_equal expected, Set.new(q.queued[:gauges])
+        assert_equal expected, Set.new(q.queued[:measurements])
       end
 
       def test_flush_percentiles
         [1,2,3].each { |i| @agg.timing 'a.timing', i, percentile: 95 }
-        [1,2,3].each { |i| @agg.timing 'b.timing', i, source: 'f', percentile: [50, 99.9] }
+        [1,2,3].each { |i| @agg.timing "b.timing", i, tags: { hostname: "f" }, percentile: [50, 99.9] }
 
-        q = Librato::Metrics::Queue.new
+        q = Librato::Metrics::Queue.new(tags: { region: "us-east-1" })
         @agg.flush_to(q)
 
-        queued = q.queued[:gauges]
+        queued = q.queued[:measurements]
         a_timing     = queued.detect{ |q| q[:name] == 'a.timing.p95' }
         b_timing_50  = queued.detect{ |q| q[:name] == 'b.timing.p50' }
         b_timing_999 = queued.detect{ |q| q[:name] == 'b.timing.p999' }
@@ -132,15 +142,44 @@ module Librato
         assert_equal 2, b_timing_50[:value]
         assert_equal 3, b_timing_999[:value]
 
-        assert_nil a_timing[:source],             'no source set'
-        assert_equal 'f', b_timing_50[:source],   'proper source set'
-        assert_equal 'f', b_timing_999[:source],  'proper source set'
+        assert_equal "f", b_timing_50[:tags][:hostname],  "proper tags set"
+        assert_equal "f", b_timing_999[:tags][:hostname], "proper tags set"
 
         # flushing clears percentages to track
-        storage = @agg.instance_variable_get('@percentiles')
-        assert_equal 0, storage['a.timing'][:percs].length, 'clears percentiles'
+        measurement = @agg.send(:fetch_percentile_store, 'a.timing', tags: @tags)
+        assert_equal 0, measurement[:percs].length, 'clears percentiles'
+      end
+
+      def test_default_tags
+        default_tags = { queue: 'priority' }
+        agg = Aggregator.new(default_tags: default_tags)
+        agg.measure 'jobs.queued', 1
+
+        assert_equal 1, agg['jobs.queued'][:sum]
+        assert_equal default_tags, agg['jobs.queued'][:tags]
+      end
+
+      def test_tags_option
+        default_tags = { queue: 'priority' }
+        tags_option = { worker: 'worker.12' }
+        agg = Aggregator.new(default_tags: default_tags)
+        agg.measure 'jobs.queued', 1, tags: tags_option
+
+        assert_equal 1, agg.fetch('jobs.queued', tags: tags_option)[:sum]
+        assert_equal tags_option, agg.fetch('jobs.queued', tags: tags_option)[:tags]
+      end
+
+      def test_inherit_tags
+        default_tags = { queue: 'priority' }
+        tags_option = { worker: 'worker.12' }
+        merged_tags = default_tags.merge(tags_option)
+        agg = Aggregator.new(default_tags: default_tags)
+        agg.measure 'jobs.queued', 1, tags: tags_option, inherit_tags: true
+
+        assert_equal 1, agg.fetch('jobs.queued', tags: merged_tags)[:sum]
+        assert_equal merged_tags, agg.fetch('jobs.queued', tags: merged_tags)[:tags]
       end
 
     end
   end
-end
+end

data/test/unit/collector/counter_cache_test.rb

@@ -5,67 +5,75 @@ module Librato
     class CounterCacheTest < Minitest::Test
 
       def test_basic_operations
-        cc = CounterCache.new
+        cc = CounterCache.new(default_tags: { host: 'metricsweb-stagevpc-1' })
         cc.increment :foo
-        assert_equal 1, cc[:foo]
+        assert_equal 1, cc[:foo][:value]
 
         # accepts optional argument
         cc.increment :foo, :by => 5
-        assert_equal 6, cc[:foo]
+        assert_equal 6, cc[:foo][:value]
 
         # legacy style
         cc.increment :foo, 2
-        assert_equal 8, cc[:foo]
+        assert_equal 8, cc[:foo][:value]
 
         # strings or symbols work
         cc.increment 'foo'
-        assert_equal 9, cc['foo']
+        assert_equal 9, cc['foo'][:value]
       end
 
-      def test_custom_sources
+      def test_custom_tags
         cc = CounterCache.new
 
-        cc.increment :foo, :source => 'bar'
-        assert_equal 1, cc.fetch(:foo, :source => 'bar')
+        cc.increment :foo, tags: { hostname: "bar" }
+        assert_equal 1, cc.fetch(:foo, tags: { hostname: "bar" })[:value]
 
         # symbols also work
-        cc.increment :foo, :source => :baz
-        assert_equal 1, cc.fetch(:foo, :source => :baz)
+        cc.increment :foo, tags: { hostname: :baz }
+        assert_equal 1, cc.fetch(:foo, tags: { hostname: :baz })[:value]
 
         # strings and symbols are interchangable
-        cc.increment :foo, :source => :bar
-        assert_equal 2, cc.fetch(:foo, :source => 'bar')
+        cc.increment :foo, tags: { hostname: :bar }
+        assert_equal 2, cc.fetch(:foo, tags: { hostname: "bar" })[:value]
 
         # custom source and custom increment
-        cc.increment :foo, :source => 'boombah', :by => 10
-        assert_equal 10, cc.fetch(:foo, :source => 'boombah')
+        cc.increment :foo, tags: { hostname: "boombah" }, by: 10
+        assert_equal 10, cc.fetch(:foo, tags: { hostname: "boombah" })[:value]
       end
 
-      def test_sporadic
+      def test_legacy_source
         cc = CounterCache.new
 
+        cc.increment :foo, source: "bar"
+
+        assert_equal 1, cc.fetch(:foo, tags: { source: "bar" })[:value]
+      end
+
+      def test_sporadic
+        cc = CounterCache.new(default_tags: { host: 'metricsweb-stagevpc-1' })
+
         cc.increment :foo
-        cc.increment :foo, :source => 'bar'
+        cc.increment :foo, tags: { hostname: "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.increment :baz, tags: { hostname: 118 }, sporadic: true
+        assert_equal 1, cc[:baz][:value]
+        assert_equal 1, cc.fetch(:baz, tags: { hostname: 118 })[:value]
 
         # 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')
+        assert_equal 0, cc[:foo][:value]
+        assert_equal 0, cc.fetch(:foo, tags: { hostname: "bar" })[:value]
 
         # sporadic do not
         assert_nil cc[:baz]
-        assert_nil cc.fetch(:baz, :source => 118)
+        assert_nil cc.fetch(:baz, tags: { hostname: 118 })
 
         # add a different sporadic metric
         cc.increment :bazoom, :sporadic => true
-        assert_equal 1, cc[:bazoom]
+        assert_equal 1, cc[:bazoom][:value]
 
         # persist values again
         cc.flush_to(Librato::Metrics::Queue.new)
@@ -73,24 +81,56 @@ module Librato
       end
 
       def test_flushing
-        cc = CounterCache.new
+        default_tags = { host: 'metricsweb-stagevpc-1' }
+        cc = CounterCache.new(default_tags: default_tags)
+        tags = { hostname: "foobar" }
 
         cc.increment :foo
         cc.increment :bar, :by => 2
-        cc.increment :foo, :source => 'foobar'
-        cc.increment :foo, :source => 'foobar', :by => 3
+        cc.increment :foo, tags: tags
+        cc.increment :foo, tags: tags, by: 3
 
-        q = Librato::Metrics::Queue.new
+        q = Librato::Metrics::Queue.new(tags: { region: "us-east-1" })
         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) }
+        expected = Set.new [{:name=>"foo", :value=>1, :tags=>default_tags},
+                    {:name=>"foo", :value=>4, :tags=>tags},
+                    {:name=>"bar", :value=>2, :tags=>default_tags}]
+        queued = Set.new(q.measurements)
+        queued.each { |hash| hash.delete(:time) }
         assert_equal queued, expected
       end
 
+      def test_default_tags
+        default_tags = { host: 'metricsweb-stagevpc-1' }
+        cc = CounterCache.new(default_tags: default_tags)
+        cc.increment 'user.signup'
+
+        assert_equal 1, cc.fetch('user.signup')[:value]
+        assert_equal default_tags, cc.fetch('user.signup')[:tags]
+      end
+
+      def test_tags_option
+        default_tags = { host: 'metricsweb-stagevpc-1' }
+        tags_option = { plan: 'developer' }
+        cc = CounterCache.new(default_tags: default_tags)
+        cc.increment 'user.signup', tags: tags_option
+
+        assert_equal 1, cc.fetch('user.signup', tags: tags_option)[:value]
+        assert_equal tags_option, cc.fetch('user.signup', tags: tags_option)[:tags]
+      end
+
+      def test_inherit_tags
+        default_tags = { host: 'metricsweb-stagevpc-1' }
+        tags_option = { plan: 'developer' }
+        merged_tags = default_tags.merge(tags_option)
+        cc = CounterCache.new(default_tags: default_tags)
+        cc.increment 'user.signup', tags: tags_option, inherit_tags: true
+
+        assert_equal 1, cc.fetch('user.signup', tags: merged_tags)[:value]
+        assert_equal merged_tags, cc.fetch('user.signup', tags: merged_tags)[:tags]
+      end
+
     end
   end
-end
+end

data/test/unit/collector/group_test.rb

@@ -4,52 +4,56 @@ module Librato
   class Collector
     class GroupTest < Minitest::Test
 
+      def setup
+        @tags = { region: "us-east-1" }
+      end
+
       def test_increment
-        collector = Collector.new
+        collector = Collector.new(tags: { host: 'metricsweb-stagevpc-1' })
         collector.group 'foo' do |g|
           g.increment :bar
-          g.increment :baz, :source => 'bang'
+          g.increment :baz, tags: @tags
         end
-        assert_equal 1, collector.counters['foo.bar']
-        assert_equal 1, collector.counters.fetch('foo.baz', source: 'bang')
+        assert_equal 1, collector.counters['foo.bar'][:value]
+        assert_equal 1, collector.counters.fetch("foo.baz", tags: @tags)[:value]
       end
 
       def test_measure
-        collector = Collector.new
+        collector = Collector.new(tags: { host: 'metricsweb-stagevpc-1' })
         collector.group 'foo' do |g|
-          g.measure :baz, 23
+          g.measure :baz, 23, tags: @tags
         end
-        assert_equal 23, collector.aggregate['foo.baz'][:sum]
+        assert_equal 23, collector.aggregate.fetch("foo.baz", tags: @tags)[:sum]
       end
 
       def test_timing
-        collector = Collector.new
+        collector = Collector.new(tags: { host: 'metricsweb-stagevpc-1' })
         collector.group 'foo' do |g|
-          g.timing :bam, 32.0
+          g.timing :bam, 32.0, tags: @tags
         end
-        assert_equal 32.0, collector.aggregate['foo.bam'][:sum]
+        assert_equal 32.0, collector.aggregate.fetch("foo.bam", tags: @tags)[:sum]
       end
 
       def test_timing_block
-        collector = Collector.new
+        collector = Collector.new(tags: { host: 'metricsweb-stagevpc-1' })
         collector.group 'foo' do |g|
-          g.timing :bak do
+          g.timing :bak, tags: @tags do
             sleep 0.01
           end
         end
-        assert_in_delta 10.0, collector.aggregate['foo.bak'][:sum], 2
+        assert_in_delta 10.0, collector.aggregate.fetch("foo.bak", tags: @tags)[:sum], 2
       end
 
       def test_nesting
-        collector = Collector.new
+        collector = Collector.new(tags: { host: 'metricsweb-stagevpc-1' })
         collector.group 'foo' do |g|
           g.group :bar do |b|
             b.increment :baz, 2
           end
         end
-        assert_equal 2, collector.counters['foo.bar.baz']
+        assert_equal 2, collector.counters['foo.bar.baz'][:value]
       end
 
     end
   end
-end
+end

data/test/unit/collector_test.rb

@@ -10,14 +10,15 @@ module Librato
     end
 
     def test_basic_grouping
-      collector = Collector.new
+      collector = Collector.new(tags: { host: 'metricsweb-stagevpc-1' })
+      tags = { region: "us-east-1" }
       collector.group 'foo' do |g|
         g.increment :bar
-        g.measure :baz, 23
+        g.measure :baz, 23, tags: tags
       end
-      assert_equal 1, collector.counters['foo.bar']
-      assert_equal 23, collector.aggregate['foo.baz'][:sum]
+      assert_equal 1, collector.counters["foo.bar"][:value]
+      assert_equal 23, collector.aggregate.fetch("foo.baz", tags: tags)[:sum]
     end
 
   end
-end
+end

data/test/unit/rack/configuration_test.rb

@@ -13,18 +13,20 @@ module Librato
         assert_equal 60, config.flush_interval
         assert_equal Librato::Metrics.api_endpoint, config.api_endpoint
         assert_equal '', config.suites
+        assert_equal Hash.new, config.tags
       end
 
       def test_environment_variable_config
         ENV['LIBRATO_USER'] = 'foo@bar.com'
         ENV['LIBRATO_TOKEN'] = 'api_key'
-        ENV['LIBRATO_SOURCE'] = 'source'
+        ENV["LIBRATO_TAGS"] = "hostname=metrics-web-stg-1"
         ENV['LIBRATO_PROXY'] = 'http://localhost:8080'
         ENV['LIBRATO_SUITES'] = 'foo,bar'
+        expected_tags = { hostname: "metrics-web-stg-1" }
         config = Configuration.new
         assert_equal 'foo@bar.com', config.user
         assert_equal 'api_key', config.token
-        assert_equal 'source', config.source
+        assert_equal expected_tags, config.tags
         assert_equal 'http://localhost:8080', config.proxy
         assert_equal 'foo,bar', config.suites
         #assert Librato::Rails.explicit_source, 'source is explicit'
@@ -36,13 +38,22 @@ module Librato
         assert_equal 'http://localhost:8888', config.proxy
       end
 
-      def test_explicit_source
+      def test_has_tags
         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'
+        assert !config.has_tags?
+        config.tags = { hostname: "tessaract" }
+        assert config.has_tags?
+        config.tags = nil
+        assert !config.has_tags?, "tags are not valid when nil"
+        config.tags = {}
+        assert !config.has_tags?, "tags are not valid when empty"
+      end
+
+      def test_invalid_tags_env_var
+        ENV["LIBRATO_TAGS"] = "loljk"
+        assert_raises Librato::Rack::InvalidTagConfiguration do
+         config = Configuration.new
+        end
       end
 
       def test_prefix_change_notification

data/test/unit/rack/tracker_test.rb

@@ -15,7 +15,7 @@ module Librato
         assert_equal 'second', tracker.collector.prefix
       end
 
-      def test_requires_explicit_source_on_heroku
+      def test_requires_tags_on_heroku
         config = Configuration.new
         config.user, config.token = 'foo', 'bar'
         @buffer = StringIO.new
@@ -24,10 +24,10 @@ module Librato
         tracker.on_heroku = true
 
         assert_equal false, tracker.send(:should_start?),
-          'should not start with implicit source on heroku'
-        assert buffer_lines[0].index('source must be provided')
+          'should not start with implicit tags on heroku'
+        assert buffer_lines[0].index("tags must be provided")
 
-        config.source = 'myapp'
+        config.tags = { hostname: "myapp" }
         new_tracker = Tracker.new(config)
         assert_equal true, new_tracker.send(:should_start?)
       end
@@ -46,6 +46,42 @@ module Librato
         ENV.delete('LIBRATO_AUTORUN')
       end
 
+      def test_invalid_tags_can_prevent_startup
+        config = Configuration.new
+        config.user, config.token = "foo", "bar"
+        @buffer = StringIO.new
+        config.log_target = @buffer
+        config.tags = { hostname: "!!!" }
+        tracker_1 = Tracker.new(config)
+
+        assert_equal false, tracker_1.send(:should_start?)
+        assert buffer_lines.to_s.include?("invalid tags")
+
+        config.tags = { "!!!" => "metrics-web-stg-1" }
+        tracker_2 = Tracker.new(config)
+
+        assert_equal false, tracker_2.send(:should_start?)
+        assert buffer_lines.to_s.include?("invalid tags")
+      end
+
+      def test_exceeding_default_tags_limit_can_prevent_startup
+        config = Configuration.new
+        config.user, config.token = "foo", "bar"
+        @buffer = StringIO.new
+        config.log_target = @buffer
+        config.tags = { a: 1, b: 2, c: 3, d: 4 }
+        tracker_1 = Tracker.new(config)
+
+        assert_equal true, tracker_1.send(:should_start?)
+
+        config.tags = { a: 1, b: 2, c: 3, d: 4, e: 5 }
+
+        tracker_2 = Tracker.new(config)
+
+        assert_equal false, tracker_2.send(:should_start?)
+        assert buffer_lines.to_s.include?("cannot exceed default tags limit")
+      end
+
       def test_suite_configured
         ENV['LIBRATO_SUITES'] = 'abc,prq'
 
@@ -66,4 +102,4 @@ module Librato
 
     end
   end
-end
+end