librato-rack 1.1.1 → 2.0.0

data/test/integration/custom_test.rb

@@ -5,33 +5,40 @@ require 'rack/test'
 #
 class CustomTest < Minitest::Test
   include Rack::Test::Methods
+  include EnvironmentHelpers
 
   def app
     Rack::Builder.parse_file('test/apps/custom.ru').first
   end
 
+  def setup
+    ENV["LIBRATO_TAGS"] = "hostname=metrics-web-stg-1"
+    @tags = { hostname: "metrics-web-stg-1" }
+  end
+
   def teardown
     # clear metrics before each run
     aggregate.delete_all
     counters.delete_all
+    clear_config_env_vars
   end
 
   def test_increment
     get '/increment'
-    assert_equal 1, counters[:hits]
+    assert_equal 1, counters[:hits][:value]
     2.times { get '/increment' }
-    assert_equal 3, counters[:hits]
+    assert_equal 3, counters[:hits][:value]
   end
 
   def test_measure
     get '/measure'
-    assert_equal 3.0, aggregate[:nodes][:sum]
-    assert_equal 1, aggregate[:nodes][:count]
+    assert_equal 3.0, aggregate.fetch(:nodes, @tags)[:sum]
+    assert_equal 1, aggregate.fetch(:nodes, @tags)[:count]
   end
 
   def test_timing
     get '/timing'
-    assert_equal 1, aggregate['lookup.time'][:count]
+    assert_equal 1, aggregate.fetch("lookup.time", @tags)[:count]
   end
 
   def test_timing_block
@@ -42,10 +49,17 @@ class CustomTest < Minitest::Test
 
   def test_grouping
     get '/group'
-    assert_equal 1, counters['did.a.thing']
+    assert_equal 1, counters['did.a.thing'][:value]
     assert_equal 1, aggregate['did.a.timing'][:count]
   end
 
+  def test_tags
+    tags = { region: "us-east-1" }
+    get '/tags'
+    assert_equal 1, counters.fetch("requests", tags: tags)[:value]
+    assert_equal 1, aggregate.fetch("requests.time", tags: tags)[:count]
+  end
+
   private
 
   def aggregate

data/test/integration/no_stats_test.rb

@@ -20,9 +20,8 @@ class NoStatsTest < Minitest::Test
     get '/'
     assert last_response.ok?
 
-    assert_nil counters["rack.request.total"]
-    assert_nil counters["rack.request.status.200"]
-    assert_nil counters["rack.request.status.2xx"]
+    assert_nil counters["rack.request"]
+    assert_nil counters["rack.request.status"]
   end
 
   def test_no_standard_measures

data/test/integration/no_suites_test.rb

@@ -24,7 +24,7 @@ class NoSuitesTest < Minitest::Test
   def test_increment_total
     get '/'
     assert last_response.ok?
-    assert_nil counters["rack.request.total"], 'should not increment'
+    assert_nil counters["rack.request"], "should not increment"
   end
 
   def test_track_queue_time
@@ -36,16 +36,15 @@ class NoSuitesTest < Minitest::Test
   def test_increment_status
     get '/'
     assert last_response.ok?
-    assert_nil counters["rack.request.status.200"], 'should not increment'
-    assert_nil counters["rack.request.status.2xx"], 'should not increment'
+    assert_nil counters["rack.request.status"], "should not increment"
   end
 
   def test_track_http_method_info
     get '/'
-    assert_nil counters['rack.request.method.get']
+    assert_nil counters["rack.request.method"]
 
     post '/'
-    assert_nil counters['rack.request.method.post']
+    assert_nil counters["rack.request.method"]
   end
 
   def test_increment_exception

data/test/integration/queue_wait_test.rb

@@ -19,13 +19,10 @@ class QueueWaitTest < Minitest::Test
   def test_milliseconds
     get '/milli'
 
-    # give jruby a bit more time since it can be slow
-    delta = defined?(JRUBY_VERSION) ? 6 : 4
-
     # puts "milli: #{aggregate["rack.request.queue.time"].inspect}"
     assert_equal 1, aggregate["rack.request.queue.time"][:count],
       'should track total queue time'
-    assert_in_delta 5, aggregate["rack.request.queue.time"][:sum], delta
+    assert_in_delta 5, aggregate["rack.request.queue.time"][:sum], 4
   end
 
   def test_microseconds
@@ -40,13 +37,10 @@ class QueueWaitTest < Minitest::Test
   def test_queue_start
     get '/queue_start'
 
-    # give jruby a bit more time since it can be slow
-    delta = defined?(JRUBY_VERSION) ? 6 : 4
-
     # puts "micro: #{aggregate["rack.request.queue.time"].inspect}"
     assert_equal 1, aggregate["rack.request.queue.time"][:count],
       'should track total queue time'
-    assert_in_delta 15, aggregate["rack.request.queue.time"][:sum], delta
+    assert_in_delta 15, aggregate["rack.request.queue.time"][:sum], 6
   end
 
   def test_with_t
@@ -55,14 +49,14 @@ class QueueWaitTest < Minitest::Test
     # puts "micro: #{aggregate["rack.request.queue.time"].inspect}"
     assert_equal 1, aggregate["rack.request.queue.time"][:count],
       'should track total queue time'
-    assert_in_delta 20, aggregate["rack.request.queue.time"][:sum], 4
+    assert_in_delta 20, aggregate["rack.request.queue.time"][:sum], 6
   end
 
   def test_with_period
     get '/with_period'
 
     # give jruby a bit more time since it can be slow
-    delta = defined?(JRUBY_VERSION) ? 10 : 4
+    delta = defined?(JRUBY_VERSION) ? 10 : 6
     assert_equal 1, aggregate["rack.request.queue.time"][:count],
       'should track total queue time'
     assert_in_delta 25, aggregate["rack.request.queue.time"][:sum], delta

data/test/integration/request_test.rb

@@ -5,29 +5,34 @@ require 'rack/test'
 #
 class RequestTest < Minitest::Test
   include Rack::Test::Methods
+  include EnvironmentHelpers
 
   def app
     Rack::Builder.parse_file('test/apps/basic.ru').first
   end
 
+  def setup
+    ENV["LIBRATO_TAGS"] = "hostname=metrics-web-stg-1"
+    @tags = { hostname: "metrics-web-stg-1" }
+  end
+
   def teardown
     # clear metrics before each run
     aggregate.delete_all
     counters.delete_all
+    clear_config_env_vars
   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"]
+    assert_equal 1, counters["rack.request.total"][:value]
+    assert_equal 1, counters.fetch("rack.request.status", tags: @tags.merge({ status: 200 }))[:value]
 
     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"]
+    assert_equal 2, counters["rack.request.total"][:value]
+    assert_equal 1, counters.fetch("rack.request.status", tags: @tags.merge({ status: 200 }))[:value], "should not increment"
+    assert_equal 1, counters.fetch("rack.request.status", tags: @tags.merge({ status: 204 }))[:value], "should increment"
   end
 
   def test_request_times
@@ -38,30 +43,22 @@ class RequestTest < Minitest::Test
       'should track total request time'
 
     # should calculate p95 value
-    assert aggregate.fetch("rack.request.time", percentile: 95) > 0.0
+    assert aggregate.fetch("rack.request.time", tags: @tags, percentile: 95) > 0.0
 
     # status specific
-    assert_equal 1, aggregate["rack.request.status.200.time"][:count]
-    assert_equal 1, aggregate["rack.request.status.2xx.time"][:count]
+    assert_equal 1, aggregate.fetch("rack.request.status.time", tags: @tags.merge({ status: 200 }))[:count]
   end
 
   def test_track_http_method_info
     get '/'
 
-    assert_equal 1, counters['rack.request.method.get']
-    assert_equal 1, aggregate['rack.request.method.get.time'][:count]
+    assert_equal 1, counters.fetch("rack.request.method", tags: @tags.merge({ method: "GET" }))[:value]
+    assert_equal 1, aggregate.fetch("rack.request.method.time", tags: @tags.merge({ method: "get" }))[:count]
 
     post '/'
 
-    assert_equal 1, counters['rack.request.method.post']
-    assert_equal 1, aggregate['rack.request.method.post.time'][:count]
-  end
-
-  def test_request_method_not_mutated
-    get '/', {}, {'REQUEST_METHOD' => "GET".freeze}
-
-    assert_equal 1, counters['rack.request.method.get']
-    assert_equal 1, aggregate['rack.request.method.get.time'][:count]
+    assert_equal 1, counters.fetch("rack.request.method", tags: @tags.merge({ method: "POST" }))[:value]
+    assert_equal 1, aggregate.fetch("rack.request.method.time", tags: @tags.merge({ method: "post" }))[:count]
   end
 
   def test_track_exceptions
@@ -70,12 +67,12 @@ class RequestTest < Minitest::Test
     rescue RuntimeError => e
       raise unless e.message == 'exception raised!'
     end
-    assert_equal 1, counters["rack.request.exceptions"]
+    assert_equal 1, counters["rack.request.exceptions"][:value]
   end
 
   def test_track_slow_requests
     get '/slow'
-    assert_equal 1, counters["rack.request.slow"]
+    assert_equal 1, counters["rack.request.slow"][:value]
   end
 
   private

data/test/integration/suites_test.rb

@@ -21,18 +21,16 @@ class SuitesTest < Minitest::Test
     assert last_response.ok?
 
     # rack.request metrics (rack suite) should get logged
-    assert_equal 1, counters["rack.request.total"]
+    assert_equal 1, counters["rack.request.total"][:value]
     assert_equal 1, aggregate["rack.request.time"][:count]
 
     # rack.request.method metrics (rack_method suite) should not get logged
-    assert_nil counters['rack.request.method.get']
-    assert_nil aggregate['rack.request.method.get.time']
+    assert_nil counters.fetch("rack.request.method", tags: { method: "GET" })
+    assert_nil aggregate.fetch("rack.request.method.time", tags: { method: "get" })
 
     # rack.request.status metrics (rack_status suite) should not get logged
-    assert_nil counters["rack.request.status.200"]
-    assert_nil counters["rack.request.status.2xx"]
-    assert_nil counters["rack.request.status.200.time"]
-    assert_nil counters["rack.request.status.2xx.time"]
+    assert_nil counters.fetch("rack.request.status", tags: { status: 200, status_message: "OK" })
+    assert_nil counters.fetch("rack.request.status.time", tags: { status: 200, status_message: "OK" })
   end
 
   private

data/test/remote/tracker_test.rb

@@ -27,24 +27,26 @@ class TrackerRemoteTest < Minitest::Test
     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.increment :foo                                    # simple
+      tracker.increment :bar, 2                                 # specified
+      tracker.increment :foo                                    # multincrement
+      tracker.increment :foo, tags: { hostname: "baz" }, by: 3  # custom source
       @queued = tracker.queued
       tracker.flush
 
+      sleep 15 # TODO: retry logic for replica delay
+
       # metrics are SSA, so should exist but won't have measurements yet
-      metric_names = client.list.map { |m| m['name'] }
+      metric_names = client.metrics.map { |m| m['name'] }
       assert metric_names.include?('foo'), 'foo should be present'
       assert metric_names.include?('bar'), 'bar should be present'
 
       # interogate queued payload for expected values
-      assert_equal source, @queued[:source]
+      assert_equal [:host], @queued[:measurements].first[:tags].keys
       assert_equal 2, queued('foo')
 
       # custom source
-      assert_equal 3, queued('foo', source: 'baz')
+      assert_equal 3, queued("foo", tags: { hostname: "baz" })
 
       # different counter
       assert_equal 2, queued('bar')
@@ -53,39 +55,41 @@ class TrackerRemoteTest < Minitest::Test
     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']
+      assert_equal 1, collector.counters['knightrider'][:value]
+      assert_equal 1, collector.counters['badguys'][:value]
 
       tracker.flush
-      assert_equal 0, collector.counters['knightrider']
+      assert_equal 0, collector.counters['knightrider'][:value]
       assert_nil collector.counters['badguys']
     end
 
     def test_flush_should_send_measures_and_timings
-      tracker.timing  'request.time.total', 122.1
+      tracker.timing  "request.time", 122.1
       tracker.measure 'items_bought', 20
-      tracker.timing  'request.time.total', 81.3
-      tracker.timing  'jobs.queued', 5, source: 'worker.3'
+      tracker.timing  "request.time", 81.3
+      tracker.timing  "jobs.queued", 5, tags: { hostname: "worker.3" }
       @queued = tracker.queued
       tracker.flush
 
+      sleep 15 # TODO: retry logic for replica delay
+
       # metrics are SSA, so should exist but won't have measurements yet
-      metric_names = client.list.map { |m| m['name'] }
-      assert metric_names.include?('request.time.total'), 'request.time.total should be present'
+      metric_names = client.metrics.map { |m| m['name'] }
+      assert metric_names.include?('request.time'), 'request.time should be present'
       assert metric_names.include?('items_bought'), 'request.time.db should be present'
 
-      assert_equal 2, queued('request.time.total')[:count]
-      assert_in_delta 203.4, queued('request.time.total')[:sum], 0.1
+      assert_equal 2, queued("request.time", tags: tags)[:count]
+      assert_in_delta 203.4, queued("request.time", tags: tags)[:sum], 0.1
 
-      assert_equal 1, queued('items_bought')[:count]
-      assert_in_delta 20, queued('items_bought')[:sum], 0.1
+      assert_equal 1, queued("items_bought", tags: tags)[:count]
+      assert_in_delta 20, queued("items_bought", tags: tags)[:sum], 0.1
 
-      assert_equal 1, queued('jobs.queued', source: 'worker.3')[:count]
-      assert_in_delta 5, queued('jobs.queued', source: 'worker.3')[:sum], 0.1
+      assert_equal 1, queued("jobs.queued", tags: { hostname: "worker.3" })[:count]
+      assert_in_delta 5, queued("jobs.queued", tags: { hostname: "worker.3" })[:sum], 0.1
     end
 
     def test_flush_should_purge_measures_and_timings
-      tracker.timing  'request.time.total', 122.1
+      tracker.timing  "request.time", 122.1
       tracker.measure 'items_bought', 20
       tracker.flush
 
@@ -94,29 +98,33 @@ class TrackerRemoteTest < Minitest::Test
     end
 
     def test_flush_respects_prefix
+      tags = { hostname: "metrics-web-stg-1" }
       config.prefix = 'testyprefix'
 
-      tracker.timing 'mytime', 221.1
+      tracker.timing "mytime", 221.1, tags: tags
       tracker.increment 'mycount', 4
       @queued = tracker.queued
       tracker.flush
 
-      metric_names = client.list.map { |m| m['name'] }
+      sleep 15 # TODO: retry logic for replica delay
+
+      metric_names = client.metrics.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'
 
-      assert_equal 1, queued('testyprefix.mytime')[:count]
+      assert_equal 1, queued("testyprefix.mytime", tags: tags)[:count]
       assert_equal 4, queued('testyprefix.mycount')
     end
 
     def test_flush_recovers_from_failure
       # create a metric foo of counter type
-      client.submit foo: {type: :counter, value: 12}
+      client.submit test_counter: { type: :counter, value: 12 }
 
       # failing flush - submit a foo measurement as a gauge (type mismatch)
-      tracker.measure :foo, 2.12
+      tracker.measure :test_counter, 2.12
 
       # won't be accepted
       tracker.flush
@@ -124,7 +132,7 @@ class TrackerRemoteTest < Minitest::Test
       tracker.measure :boo, 2.12
       tracker.flush
 
-      metric_names = client.list.map { |m| m['name'] }
+      metric_names = client.metrics.map { |m| m['name'] }
       assert metric_names.include?('boo')
     end
 
@@ -135,24 +143,24 @@ class TrackerRemoteTest < Minitest::Test
       @queued = tracker.queued
       tracker.flush
 
-      metric_names = client.list.map { |m| m['name'] }
+      metric_names = client.metrics.map { |m| m['name'] }
       assert metric_names.include?('foo')
 
       # should be sending value for foo
       assert_equal 1.0, queued('foo')
     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
+    def test_flush_handles_invalid_tags
+      tracker.increment :foo, tags: { hostname: "atreides" }        # valid
+      tracker.increment :bar, tags: { hostname: "glébnöst" }        # invalid
+      tracker.measure 'baz', 2.25, tags: { hostname: "b/l/ak/nok" } # invalid
       @queued = tracker.queued
       tracker.flush
 
-      metric_names = client.list.map { |m| m['name'] }
+      metric_names = client.metrics.map { |m| m['name'] }
       assert metric_names.include?('foo')
 
-      assert_equal 1.0, queued('foo', source: 'atreides')
+      assert_equal 1.0, queued("foo", tags: { hostname: "atreides" })
     end
 
     private
@@ -176,29 +184,29 @@ class TrackerRemoteTest < Minitest::Test
     # wrapper to make api format more easy to query
     def queued(name, opts={})
       raise "No queued found" unless @queued
-      source = opts[:source]  || nil
+      tags_query = opts.fetch(:tags, nil)
 
-      @queued[:gauges].each do |g|
-        if g[:name] == name.to_s && g[:source] == source
-          if g[:count]
+      @queued[:measurements].each do |measurement|
+        if measurement[:name] == name.to_s && measurement[:tags] == tags_query || measurement[:name] == name.to_s && @queued[:tags] == tags_query
+          if measurement[:count]
             # complex metric, return the whole hash
-            return g
+            return measurement
           else
             # return just the value
-            return g[:value]
+            return measurement[:value]
           end
         end
       end
       raise "No queued entry with '#{name}' found."
     end
 
-    def source
-      @tracker.qualified_source
+    def tags
+      @tracker.send(:tags)
     end
 
     def delete_all_metrics
-      metric_names = client.list.map { |metric| metric['name'] }
-      client.delete(*metric_names) if !metric_names.empty?
+      metric_names = client.metrics.map { |metric| metric['name'] }
+      client.delete_metrics(*metric_names) if !metric_names.empty?
     end
 
   else

data/test/support/environment_helpers.rb

@@ -7,7 +7,7 @@ module EnvironmentHelpers
     ENV.delete('LIBRATO_USER')
     ENV.delete('LIBRATO_TOKEN')
     ENV.delete('LIBRATO_PROXY')
-    ENV.delete('LIBRATO_SOURCE')
+    ENV.delete("LIBRATO_TAGS")
     ENV.delete('LIBRATO_PREFIX')
     ENV.delete('LIBRATO_SUITES')
     ENV.delete('LIBRATO_LOG_LEVEL')

data/test/test_helper.rb

@@ -6,4 +6,4 @@ require 'minitest/autorun'
 
 require 'librato/rack'
 
-require_relative 'support/environment_helpers'
+require_relative 'support/environment_helpers'