metriks-opentsdb 1.1.3 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1f0fcaf84f504d87dd4dc7e02fad84add07d7225
-  data.tar.gz: f66af80bd062960f3f10d8de994fbffbc0343a20
+  metadata.gz: 2d5f830258daa7e1b9e52283f7ed9f0610ace967
+  data.tar.gz: a5d6f6f2fe786eed74d365aa0f6ba80590b38415
 SHA512:
-  metadata.gz: 3069230f7767bb82941ebf75e9299c67fa78e5cb350d1c12c667315701f089656fdf74e5fc89f7df3e47e81c8d789145e8c47ab57dc7e03eb07fa8d569d60af5
-  data.tar.gz: a93c71eedba246add2e6277a8c7dae84d9032334187fb517b89eab76356f560fe8020e847e54a6af70321ab5ac722069e114c3d033e64c2c88d2bff58a19f651
+  metadata.gz: 7b589f243c7743aefd9e69504829e8e1f60f36aba60b7027843143ea97d36244d0f9eee1a1c28ffb34a807f1851b9f0c5ff4be09913681f8222c95c575e4c11f
+  data.tar.gz: a5577b451589159628fbe9605559499ec7551533733d16a8210171b347c59b88abfcddbb5d63880139acf2a00ce737c222d0a2462d1a8115bf0896e47fe1ff70

data/lib/metriks-opentsdb.rb

@@ -1,5 +1,5 @@
 require 'metriks/opentsdb_reporter'
 
 module MetriksOpenTSDB
-  VERSION = '1.1.3'
+  VERSION = '1.2.0'
 end

data/lib/metriks/opentsdb_reporter.rb

@@ -1,9 +1,10 @@
 require 'metriks/time_tracker'
 require 'rest-client'
+require 'logger'
 
 module Metriks
   class OpenTSDBReporter
-    attr_accessor :prefix, :source, :data, :hostname, :tags
+    attr_accessor :prefix, :source, :data, :hostname, :tags, :logger
 
     def initialize(h, t, options = {})
       @hostname = h
@@ -29,9 +30,9 @@ module Metriks
       @running = false
     end
 
-    def info(msg)
+    def log(level, msg)
       if !@logger.nil?
-        @logger.info(msg)
+        @logger.send level, msg
       end
     end
 
@@ -69,14 +70,11 @@ module Metriks
     def flush
       begin
         @mutex.synchronize do
-          info("Flushing metrics")
+          log "debug", "Flushing metrics"
           submit get_datapoints
         end
       rescue Exception => ex
-        if !@logger.nil?
-          @logger.error(ex.message)
-          @logger.error(ex.stacktrace)
-        end
+        log "error",ex.message
         @on_error[ex] rescue nil
       end
     end
@@ -87,25 +85,20 @@ module Metriks
       index = 0
       length = @batch_size
       while index < datapoints.size
-        info("Starting from #{index}")
         to_send = nil
         if datapoints.size < (index + length)
           length = datapoints.size - index
         else
           length = @batch_size
         end
-        info("Length is #{length}")
-        info("Begin post")
-        info(datapoints[index, length].inspect)
-        info("To Json")
         jsonstr = datapoints[index, length].to_json
-        info("Send to rest")
         RestClient.post "#{@hostname}/api/put",
           jsonstr,
           :content_type => :json, :accept => :json
-        info("Put done")
+        log "debug", "Sent #{length} metrics from #{index}"
         index += length
       end
+      log "info", "Sent #{datapoints.size} metrics"
     end
 
     def get_datapoints
@@ -115,105 +108,78 @@ module Metriks
       @registry.each do |name, metric|
         next if name.nil? || name.empty?
         name = name.to_s.gsub(/ +/, '_')
+        if @prefix
+          name = "#{@prefix}.#{name}"
+        end
 
         case metric
         when Metriks::Meter
-          datapoints << {
-            :metric => "#{name}.count",
-            :timestamp => time,
-            :value => metric.count,
-            :tags => @tags
-          }
-          datapoints << {
-            :metric => "#{name}.mean_rate",
-            :timestamp => time,
-            :value => metric.mean_rate,
-            :tags => @tags
-          }
-          datapoints << {
-            :metric => "#{name}.m1",
-            :timestamp => time,
-            :value => metric.one_minute_rate,
-            :tags => @tags
-          }
-          datapoints << {
-            :metric => "#{name}.m5",
-            :timestamp => time,
-            :value => metric.five_minute_rate,
-            :tags => @tags
-          }
-          datapoints << {
-            :metric => "#{name}.m15",
-            :timestamp => time,
-            :value => metric.fifteen_minute_rate,
-            :tags => @tags
-          }
+          datapoints |= create_datapoints name, metric, time, [
+            :count, :one_minute_rate, :five_minute_rate,
+            :fifteen_minute_rate, :mean_rate
+          ]
         when Metriks::Counter
-          datapoints << {
-            :metric => name,
-            :timestamp => time,
-            :value => metric.count,
-            :tags => @tags
-          }
+          datapoints |= create_datapoints name, metric, time, [
+            :count
+          ]
         when Metriks::Gauge
+          datapoints |= create_datapoints name, metric, time, [
+            :value
+          ]
+        when Metriks::UtilizationTimer
+          datapoints |= create_datapoints name, metric, time, [
+            :count, :one_minute_rate, :five_minute_rate,
+            :fifteen_minute_rate, :mean_rate,
+            :min, :max, :mean, :stddev,
+            :one_minute_utilization, :five_minute_utilization,
+            :fifteen_minute_utilization, :mean_utilization,
+          ], [
+            :median, :get_95th_percentile
+          ]
+
+          when Metriks::Timer
+          datapoints |= create_datapoints name, metric, time, [
+            :count, :one_minute_rate, :five_minute_rate,
+            :fifteen_minute_rate, :mean_rate,
+            :min, :max, :mean, :stddev
+          ], [
+            :median, :get_95th_percentile
+          ]
+          when Metriks::Histogram
+          datapoints |= create_datapoints name, metric, time, [
+            :count, :min, :max, :mean, :stddev
+          ], [
+            :median, :get_95th_percentile
+          ]
+        end
+      end
+      datapoints
+    end
+
+    def create_datapoints(base_name, metric, time, keys, snapshot_keys = [])
+      datapoints = []
+      keys.flatten.each do |key|
+        name = key.to_s.gsub(/^get_/, '')
+        datapoints << {
+          :metric => "#{base_name}.#{name}",
+          :timestamp => time,
+          :value => metric.send(key),
+          :tags => @tags
+        }
+      end
+
+      unless snapshot_keys.empty?
+        snapshot = metric.snapshot
+        snapshot_keys.flatten.each do |key|
+          name = key.to_s.gsub(/^get_/, '')
           datapoints << {
-            :metric => name,
-            :timestamp => time,
-            :value => metric.value,
-            :tags => @tags
-          }
-        when Metriks::Histogram, Metriks::Timer, Metriks::UtilizationTimer
-          datapoints << {
-            :metric => "#{name}.count",
-            :timestamp => time,
-            :value => metric.count,
-            :tags => @tags
-          }
-          if Metriks::UtilizationTimer === metric || Metriks::Timer === metric
-            datapoints << {
-              :metric => "#{name}.mean_rate",
-              :timestamp => time,
-              :value => metric.mean_rate,
-              :tags => @tags
-            }
-            datapoints << {
-              :metric => "#{name}.m1",
-              :timestamp => time,
-              :value => metric.one_minute_rate,
-              :tags => @tags
-            }
-            datapoints << {
-              :metric => "#{name}.m5",
-              :timestamp => time,
-              :value => metric.five_minute_rate,
-              :tags => @tags
-            }
-            datapoints << {
-              :metric => "#{name}.m15",
-              :timestamp => time,
-              :value => metric.fifteen_minute_rate,
-              :tags => @tags
-            }
-          end
-          snapshot = metric.snapshot
-          datapoints << {
-            :metric => "#{name}.median",
+            :metric => "#{base_name}.#{name}",
             :timestamp => time,
-            :value => snapshot.median,
+            :value => snapshot.send(key),
             :tags => @tags
           }
-
-          @percentiles.each do |percentile|
-            datapoints << {
-              :metric => "#{name}.p#{(percentile * 100).to_i}",
-              :timestamp => time,
-              :value => snapshot.value(percentile),
-              :tags => @tags
-            }
-          end
         end
       end
-      info("Captured #{datapoints.size} metrics")
       datapoints
     end
   end

data/metriks-opentsdb.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'metriks-opentsdb'
-  s.version           = '1.1.3'
+  s.version           = '1.2.0'
   s.date              = '2015-08-03'
 
   ## Make sure your summary is short. The description may be as long

data/spec/opentsdb_spec.rb

@@ -29,23 +29,23 @@ describe "Smoke test" do
     expect(datapoints[0][:tags]).to include(:env => "test")
     expect(datapoints[0][:timestamp]).not_to be_nil
 
-    expect(datapoints[1][:metric]).to eql("meter.testing.mean_rate")
+    expect(datapoints[1][:metric]).to eql("meter.testing.one_minute_rate")
     expect(datapoints[1][:value]).not_to be_nil
     expect(datapoints[1][:tags]).to include(:env => "test")
     expect(datapoints[1][:timestamp]).not_to be_nil
 
-    expect(datapoints[2][:metric]).to eql("meter.testing.m1")
+    expect(datapoints[2][:metric]).to eql("meter.testing.five_minute_rate")
     expect(datapoints[2][:value]).to eql(0.0)
     expect(datapoints[2][:tags]).to include(:env => "test")
     expect(datapoints[2][:timestamp]).not_to be_nil
 
-    expect(datapoints[3][:metric]).to eql("meter.testing.m5")
+    expect(datapoints[3][:metric]).to eql("meter.testing.fifteen_minute_rate")
     expect(datapoints[3][:value]).to eql(0.0)
     expect(datapoints[3][:tags]).to include(:env => "test")
     expect(datapoints[3][:timestamp]).not_to be_nil
 
-    expect(datapoints[4][:metric]).to eql("meter.testing.m15")
-    expect(datapoints[4][:value]).to eql(0.0)
+    expect(datapoints[4][:metric]).to eql("meter.testing.mean_rate")
+    expect(datapoints[4][:value]).not_to be_nil
     expect(datapoints[4][:tags]).to include(:env => "test")
     expect(datapoints[4][:timestamp]).not_to be_nil
   end
@@ -54,7 +54,7 @@ describe "Smoke test" do
     @registry.counter('counter.testing').increment
     datapoints = @reporter.get_datapoints
     expect(datapoints.size).to eql(1)
-    expect(datapoints[0][:metric]).to eql("counter.testing")
+    expect(datapoints[0][:metric]).to eql("counter.testing.count")
     expect(datapoints[0][:value]).to eql(1)
     expect(datapoints[0][:tags]).to include(:env => "test")
     expect(datapoints[0][:timestamp]).not_to be_nil
@@ -63,78 +63,108 @@ describe "Smoke test" do
   it "timer" do
     @registry.timer('timer.testing').update(1.5)
     datapoints = @reporter.get_datapoints
-    expect(datapoints.size).to eql(8)
+    expect(datapoints.size).to eql(11)
     expect(datapoints[0][:metric]).to eql("timer.testing.count")
     expect(datapoints[0][:value]).to eql(1)
     expect(datapoints[0][:tags]).to include(:env => "test")
     expect(datapoints[0][:timestamp]).not_to be_nil
 
-    expect(datapoints[1][:metric]).to eql("timer.testing.mean_rate")
+    expect(datapoints[1][:metric]).to eql("timer.testing.one_minute_rate")
     expect(datapoints[1][:value]).not_to be_nil
     expect(datapoints[1][:tags]).to include(:env => "test")
     expect(datapoints[1][:timestamp]).not_to be_nil
 
-    expect(datapoints[2][:metric]).to eql("timer.testing.m1")
+    expect(datapoints[2][:metric]).to eql("timer.testing.five_minute_rate")
     expect(datapoints[2][:value]).to eql(0.0)
     expect(datapoints[2][:tags]).to include(:env => "test")
     expect(datapoints[2][:timestamp]).not_to be_nil
 
-    expect(datapoints[3][:metric]).to eql("timer.testing.m5")
+    expect(datapoints[3][:metric]).to eql("timer.testing.fifteen_minute_rate")
     expect(datapoints[3][:value]).to eql(0.0)
     expect(datapoints[3][:tags]).to include(:env => "test")
     expect(datapoints[3][:timestamp]).not_to be_nil
 
-    expect(datapoints[4][:metric]).to eql("timer.testing.m15")
-    expect(datapoints[4][:value]).to eql(0.0)
+    expect(datapoints[4][:metric]).to eql("timer.testing.mean_rate")
+    expect(datapoints[4][:value]).not_to be_nil
     expect(datapoints[4][:tags]).to include(:env => "test")
     expect(datapoints[4][:timestamp]).not_to be_nil
 
-    expect(datapoints[5][:metric]).to eql("timer.testing.median")
-    expect(datapoints[5][:value]).to eql(1.5)
+    expect(datapoints[5][:metric]).to eql("timer.testing.min")
+    expect(datapoints[5][:value]).not_to be_nil
     expect(datapoints[5][:tags]).to include(:env => "test")
     expect(datapoints[5][:timestamp]).not_to be_nil
 
-    expect(datapoints[6][:metric]).to eql("timer.testing.p95")
-    expect(datapoints[6][:value]).to eql(1.5)
+    expect(datapoints[6][:metric]).to eql("timer.testing.max")
+    expect(datapoints[6][:value]).not_to be_nil
     expect(datapoints[6][:tags]).to include(:env => "test")
     expect(datapoints[6][:timestamp]).not_to be_nil
 
-    expect(datapoints[7][:metric]).to eql("timer.testing.p99")
-    expect(datapoints[7][:value]).to eql(1.5)
+    expect(datapoints[7][:metric]).to eql("timer.testing.mean")
+    expect(datapoints[7][:value]).not_to be_nil
     expect(datapoints[7][:tags]).to include(:env => "test")
     expect(datapoints[7][:timestamp]).not_to be_nil
+
+    expect(datapoints[8][:metric]).to eql("timer.testing.stddev")
+    expect(datapoints[8][:value]).not_to be_nil
+    expect(datapoints[8][:tags]).to include(:env => "test")
+    expect(datapoints[8][:timestamp]).not_to be_nil
+
+    expect(datapoints[9][:metric]).to eql("timer.testing.median")
+    expect(datapoints[9][:value]).not_to be_nil
+    expect(datapoints[9][:tags]).to include(:env => "test")
+    expect(datapoints[9][:timestamp]).not_to be_nil
+
+    expect(datapoints[10][:metric]).to eql("timer.testing.95th_percentile")
+    expect(datapoints[10][:value]).not_to be_nil
+    expect(datapoints[10][:tags]).to include(:env => "test")
+    expect(datapoints[10][:timestamp]).not_to be_nil
   end
 
   it "histogram" do
     @registry.histogram('histogram.testing').update(1.5)
     datapoints = @reporter.get_datapoints
-    expect(datapoints.size).to eql(4)
+    expect(datapoints.size).to eql(7)
     expect(datapoints[0][:metric]).to eql("histogram.testing.count")
     expect(datapoints[0][:value]).to eql(1)
     expect(datapoints[0][:tags]).to include(:env => "test")
     expect(datapoints[0][:timestamp]).not_to be_nil
 
-    expect(datapoints[1][:metric]).to eql("histogram.testing.median")
-    expect(datapoints[1][:value]).to eql(1.5)
+    expect(datapoints[1][:metric]).to eql("histogram.testing.min")
+    expect(datapoints[1][:value]).not_to be_nil
     expect(datapoints[1][:tags]).to include(:env => "test")
     expect(datapoints[1][:timestamp]).not_to be_nil
 
-    expect(datapoints[2][:metric]).to eql("histogram.testing.p95")
-    expect(datapoints[2][:value]).to eql(1.5)
+    expect(datapoints[2][:metric]).to eql("histogram.testing.max")
+    expect(datapoints[2][:value]).not_to be_nil
     expect(datapoints[2][:tags]).to include(:env => "test")
     expect(datapoints[2][:timestamp]).not_to be_nil
 
-    expect(datapoints[3][:metric]).to eql("histogram.testing.p99")
-    expect(datapoints[3][:value]).to eql(1.5)
+    expect(datapoints[3][:metric]).to eql("histogram.testing.mean")
+    expect(datapoints[3][:value]).not_to be_nil
     expect(datapoints[3][:tags]).to include(:env => "test")
     expect(datapoints[3][:timestamp]).not_to be_nil
+
+    expect(datapoints[4][:metric]).to eql("histogram.testing.stddev")
+    expect(datapoints[4][:value]).not_to be_nil
+    expect(datapoints[4][:tags]).to include(:env => "test")
+    expect(datapoints[4][:timestamp]).not_to be_nil
+
+    expect(datapoints[5][:metric]).to eql("histogram.testing.median")
+    expect(datapoints[5][:value]).not_to be_nil
+    expect(datapoints[5][:tags]).to include(:env => "test")
+    expect(datapoints[5][:timestamp]).not_to be_nil
+
+    expect(datapoints[6][:metric]).to eql("histogram.testing.95th_percentile")
+    expect(datapoints[6][:value]).not_to be_nil
+    expect(datapoints[6][:tags]).to include(:env => "test")
+    expect(datapoints[6][:timestamp]).not_to be_nil
   end
 
   it "gauge" do
     @registry.gauge('gauge.testing') { 123 }
     datapoints = @reporter.get_datapoints
     expect(datapoints.size).to eql(1)
-    expect(datapoints[0][:metric]).to eql("gauge.testing")
+    expect(datapoints[0][:metric]).to eql("gauge.testing.value")
     expect(datapoints[0][:value]).to eql(123)
     expect(datapoints[0][:tags]).to include(:env => "test")
     expect(datapoints[0][:timestamp]).not_to be_nil
@@ -147,7 +177,7 @@ describe "Rest Client" do
     @reporter = Metriks::OpenTSDBReporter.new(
       'http://localhost:4242',
       {:env => "test"},
-      { :registry => @registry})
+      { :registry => @registry, :batch_size => 3})
     stub_request(:post, "http://localhost:4242/api/put").
       with(:body => /^\[.*\]$/).
       to_return(:status => 200, :body => "", :headers => {})
@@ -183,7 +213,7 @@ describe "Rest Client" do
   end
 
   it "Send a five metric" do
-    for i in 0..24 do
+    for i in 0..4 do
       @registry.counter("counter.testing.#{i}").increment
     end
     @reporter.submit @reporter.get_datapoints

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: metriks-opentsdb
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.2.0
 platform: ruby
 authors:
 - Rajat Venkatesh