rubycut-metriks 0.9.9.4

data/lib/metriks/reporter/graphite.rb

@@ -0,0 +1,119 @@
+require 'socket'
+
+module Metriks::Reporter
+  class Graphite
+    attr_reader :host, :port
+
+    def initialize(host, port, options = {})
+      @host = host
+      @port = port
+
+      @prefix = options[:prefix]
+
+      @registry  = options[:registry] || Metriks::Registry.default
+      @interval  = options[:interval] || 60
+      @on_error  = options[:on_error] || proc { |ex| }
+    end
+
+    def socket
+      @socket = nil if @socket && @socket.closed?
+      @socket ||= TCPSocket.new(@host, @port)
+    end
+
+    def start
+      @thread ||= Thread.new do
+        loop do
+          sleep @interval
+
+          Thread.new do
+            begin
+              write
+            rescue Exception => ex
+              @on_error[ex] rescue nil
+            end
+          end
+        end
+      end
+    end
+
+    def stop
+      @thread.kill if @thread
+      @thread = nil
+    end
+
+    def restart
+      stop
+      start
+    end
+
+    def write
+      @registry.each do |name, metric|
+        case metric
+        when Metriks::Meter
+          write_metric name, metric, [
+            :count, :one_minute_rate, :five_minute_rate,
+            :fifteen_minute_rate, :mean_rate
+          ]
+        when Metriks::Counter
+          write_metric name, metric, [
+            :count
+          ]
+        when Metriks::Gauge
+          write_metric name, metric, [
+            :value
+          ]
+        when Metriks::UtilizationTimer
+          write_metric name, metric, [
+            :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
+          write_metric name, metric, [
+            :count, :one_minute_rate, :five_minute_rate,
+            :fifteen_minute_rate, :mean_rate,
+            :min, :max, :mean, :stddev
+          ], [
+            :median, :get_95th_percentile
+          ]
+        when Metriks::Histogram
+          write_metric name, metric, [
+            :count, :min, :max, :mean, :stddev
+          ], [
+            :median, :get_95th_percentile
+          ]
+        end
+      end
+    end
+
+    def write_metric(base_name, metric, keys, snapshot_keys = [])
+      time = Time.now.to_i
+
+      base_name = base_name.to_s.gsub(/ +/, '_')
+      if @prefix
+        base_name = "#{@prefix}.#{base_name}"
+      end
+
+      keys.flatten.each do |key|
+        name = key.to_s.gsub(/^get_/, '')
+        value = metric.send(key)
+        socket.write("#{base_name}.#{name} #{value} #{time}\n")
+      end
+
+      unless snapshot_keys.empty?
+        snapshot = metric.snapshot
+        snapshot_keys.flatten.each do |key|
+          name = key.to_s.gsub(/^get_/, '')
+          value = snapshot.send(key)
+          socket.write("#{base_name}.#{name} #{value} #{time}\n")
+        end
+      end
+    rescue Errno::EPIPE
+      socket.close
+    end
+  end
+end

data/lib/metriks/reporter/librato_metrics.rb

@@ -0,0 +1,185 @@
+require 'metriks/time_tracker'
+require 'net/https'
+
+module Metriks::Reporter
+  class LibratoMetrics
+    attr_accessor :prefix, :source
+
+    def initialize(email, token, options = {})
+      @email = email
+      @token = token
+
+      @prefix = options[:prefix]
+      @source = options[:source]
+
+      @registry  = options[:registry] || Metriks::Registry.default
+      @time_tracker = Metriks::TimeTracker.new(options[:interval] || 60)
+      @on_error  = options[:on_error] || proc { |ex| }
+    end
+
+    def start
+      @thread ||= Thread.new do
+        loop do
+          @time_tracker.sleep
+
+          Thread.new do
+            begin
+              write
+            rescue Exception => ex
+              @on_error[ex] rescue nil
+            end
+          end
+        end
+      end
+    end
+
+    def stop
+      @thread.kill if @thread
+      @thread = nil
+    end
+
+    def restart
+      stop
+      start
+    end
+
+    def write
+      gauges = []
+      @registry.each do |name, metric|
+        gauges << case metric
+        when Metriks::Meter
+          prepare_metric name, metric, [
+            :count, :one_minute_rate, :five_minute_rate,
+            :fifteen_minute_rate, :mean_rate
+          ]
+        when Metriks::Counter
+          prepare_metric name, metric, [
+            :count
+          ]
+        when Metriks::Gauge
+          prepare_metric name, metric, [
+            :value
+          ]
+        when Metriks::UtilizationTimer
+          prepare_metric name, metric, [
+            :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
+          prepare_metric name, metric, [
+            :count, :one_minute_rate, :five_minute_rate,
+            :fifteen_minute_rate, :mean_rate,
+            :min, :max, :mean, :stddev
+          ], [
+            :median, :get_95th_percentile
+          ]
+        when Metriks::Histogram
+          prepare_metric name, metric, [
+            :count, :min, :max, :mean, :stddev
+          ], [
+            :median, :get_95th_percentile
+          ]
+        end
+      end
+
+      gauges.flatten!
+
+      unless gauges.empty?
+        submit(form_data(gauges.flatten))
+      end
+    end
+
+    def submit(data)
+      url = URI.parse('https://metrics-api.librato.com/v1/metrics')
+      req = Net::HTTP::Post.new(url.path)
+      req.basic_auth(@email, @token)
+      req.set_form_data(data)
+
+      http = Net::HTTP.new(url.host, url.port)
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      http.use_ssl = true
+      store = OpenSSL::X509::Store.new
+      store.set_default_paths
+      http.cert_store = store
+
+      case res = http.start { |http| http.request(req) }
+      when Net::HTTPSuccess, Net::HTTPRedirection
+        # OK
+      else
+        res.error!
+      end
+    end
+
+    def form_data(metrics)
+      data = {}
+
+      gauges = metrics.select { |m| m[:type] == "gauge" }
+
+      gauges.each_with_index do |gauge, idx|
+        gauge.each do |key, value|
+          if value
+            data["gauges[#{idx}][#{key}]"] = value.to_s
+          end
+        end
+      end
+
+      counters = metrics.select { |m| m[:type] == "counter" }
+
+      counters.each_with_index do |counter, idx|
+        counter.each do |key, value|
+          if value
+            data["counters[#{idx}][#{key}]"] = value.to_s
+          end
+        end
+      end
+
+      data
+    end
+
+    def prepare_metric(base_name, metric, keys, snapshot_keys = [])
+      results = []
+      time = @time_tracker.now_floored
+
+      base_name = base_name.to_s.gsub(/ +/, '_')
+      if @prefix
+        base_name = "#{@prefix}.#{base_name}"
+      end
+
+      keys.flatten.each do |key|
+        name = key.to_s.gsub(/^get_/, '')
+        value = metric.send(key)
+
+        results << {
+          :type => name.to_s == "count" ? "counter" : "gauge",
+          :name => "#{base_name}.#{name}",
+          :source => @source,
+          :measure_time => time,
+          :value => value
+        }
+      end
+
+      unless snapshot_keys.empty?
+        snapshot = metric.snapshot
+        snapshot_keys.flatten.each do |key|
+          name = key.to_s.gsub(/^get_/, '')
+          value = snapshot.send(key)
+
+          results << {
+            :type => name.to_s == "count" ? "counter" : "gauge",
+            :name => "#{base_name}.#{name}",
+            :source => @source,
+            :measure_time => time,
+            :value => value
+          }
+        end
+      end
+
+      results
+    end
+  end
+end

data/lib/metriks/reporter/logger.rb

@@ -0,0 +1,129 @@
+require 'logger'
+require 'metriks/time_tracker'
+
+module Metriks::Reporter
+  class Logger
+    attr_accessor :prefix, :log_level, :logger
+
+    def initialize(options = {})
+      @logger    = options[:logger]    || ::Logger.new(STDOUT)
+      @log_level = options[:log_level] || ::Logger::INFO
+      @prefix    = options[:prefix]    || 'metriks:'
+
+      @registry     = options[:registry] || Metriks::Registry.default
+      @time_tracker = Metriks::TimeTracker.new(options[:interval] || 60)
+      @on_error     = options[:on_error] || proc { |ex| }
+    end
+
+    def start
+      @thread ||= Thread.new do
+        loop do
+          @time_tracker.sleep
+
+          begin
+            write
+          rescue Exception => ex
+            @on_error[ex] rescue nil
+          end
+        end
+      end
+    end
+
+    def stop
+      @thread.kill if @thread
+      @thread = nil
+    end
+
+    def restart
+      stop
+      start
+    end
+
+    def flush
+      if !@last_write || @last_write.min != Time.now.min
+        write
+      end
+    end
+
+    def write
+      @last_write = Time.now
+
+      @registry.each do |name, metric|
+        case metric
+        when Metriks::Meter
+          log_metric name, 'meter', metric, [
+            :count, :one_minute_rate, :five_minute_rate,
+            :fifteen_minute_rate, :mean_rate
+          ]
+        when Metriks::Counter
+          log_metric name, 'counter', metric, [
+            :count
+          ]
+        when Metriks::Gauge
+          log_metric name, 'gauge', metric, [
+            :value
+          ]
+        when Metriks::UtilizationTimer
+          log_metric name, 'utilization_timer', metric, [
+            :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
+          log_metric name, 'timer', metric, [
+            :count, :one_minute_rate, :five_minute_rate,
+            :fifteen_minute_rate, :mean_rate,
+            :min, :max, :mean, :stddev
+          ], [
+            :median, :get_95th_percentile
+          ]
+        when Metriks::Histogram
+          log_metric name, 'histogram', metric, [
+            :count, :min, :max, :mean, :stddev
+          ], [
+            :median, :get_95th_percentile
+          ]
+        end
+      end
+    end
+
+    def extract_from_metric(metric, *keys)
+      keys.flatten.collect do |key|
+        name = key.to_s.gsub(/^get_/, '')
+        [ { name => metric.send(key) } ]
+      end
+    end
+
+    def log_metric(name, type, metric, keys, snapshot_keys = [])
+      message = []
+
+      message << @prefix if @prefix
+      message << { :time => Time.now.to_i }
+
+      message << { :name => name }
+      message << { :type => type }
+      message += extract_from_metric(metric, keys)
+
+      unless snapshot_keys.empty?
+        snapshot = metric.snapshot
+        message += extract_from_metric(snapshot, snapshot_keys)
+      end
+
+      @logger.add(@log_level, format_message(message))
+    end
+
+    def format_message(args)
+      args.map do |arg|
+        case arg
+        when Hash then arg.map { |name, value| "#{name}=#{format_message([value])}" }
+        when Array then format_message(arg)
+        else arg
+        end
+      end.join(' ')
+    end
+  end
+end

data/lib/metriks/reporter/proc_title.rb

@@ -0,0 +1,65 @@
+module Metriks::Reporter
+  class ProcTitle
+    def initialize(options = {})
+      @rounding = options[:rounding] || 1
+      @prefix   = options[:prefix]   || $0.dup
+
+      @interval  = options[:interval] || 5
+      @on_error  = options[:on_error] || proc { |ex| }
+
+      @metrics  = []
+    end
+
+    def add(name, suffix = nil, &block)
+      @metrics << [ name, suffix, block ]
+    end
+
+    def empty?
+      @metrics.empty?
+    end
+
+    def start
+      @thread ||= Thread.new do
+        loop do
+          begin
+            unless @metrics.empty?
+              title = generate_title
+              if title && !title.empty?
+                $0 = "#{@prefix} #{title}"
+              end
+            end
+          rescue Exception => ex
+            @on_error[ex] rescue nil
+          end
+          sleep @interval
+        end
+      end
+    end
+
+    def stop
+      @thread.kill if @thread
+      @thread = nil
+    end
+
+    def restart
+      stop
+      start
+    end
+
+    protected
+    def generate_title
+      @metrics.collect do |name, suffix, block|
+        val = block.call
+        val = "%.#{@rounding}f" % val if val.is_a?(Float)
+
+        if suffix == '%'
+          "#{name}: #{val}#{suffix}"
+        elsif suffix
+          "#{name}: #{val}/#{suffix}"
+        else
+          "#{name}: #{val}"
+        end
+      end.join(' ')
+    end
+  end
+end

data/lib/metriks/reporter/riemann.rb

@@ -0,0 +1,119 @@
+module Metriks::Reporter
+  class Riemann
+    require 'riemann/client'
+
+    attr_accessor :client
+    def initialize(options = {})
+      @client = ::Riemann::Client.new(
+        :host => options[:host],
+        :port => options[:port]
+      )
+      @registry = options[:registry] || Metriks::Registry.default
+      @interval = options[:interval] || 60
+      @on_error = options[:on_error] || proc { |ex| }
+      
+      @default_event = options[:default_event] || {}
+      @default_event[:ttl] ||= @interval * 1.5
+    end
+
+    def start
+      @thread ||= Thread.new do
+        loop do
+          sleep @interval
+          
+          Thread.new do
+            begin
+              write
+            rescue Exception => ex
+              @on_error[ex] rescue nil
+            end
+          end
+        end
+      end
+    end
+
+    def stop
+      @thread.kill if @thread
+      @thread = nil
+    end
+
+    def restart
+      stop
+      start
+    end
+
+    def flush
+      # Is this supposed to take interval into account? --aphyr
+      if !@last_write || @last_write.min != Time.now.min
+        write
+      end
+    end
+
+    def write
+      @last_write = Time.now
+
+      @registry.each do |name, metric|
+        case metric
+        when Metriks::Meter
+          send_metric name, 'meter', metric, [
+            :count, :one_minute_rate, :five_minute_rate,
+            :fifteen_minute_rate, :mean_rate
+          ]
+        when Metriks::Counter
+          send_metric name, 'counter', metric, [
+            :count
+          ]
+        when Metriks::Gauge
+          send_metric name, 'gauge', metric, [
+            :value
+          ]
+        when Metriks::UtilizationTimer
+          send_metric name, 'utilization_timer', metric, [
+            :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
+          send_metric name, 'timer', metric, [
+            :count, :one_minute_rate, :five_minute_rate,
+            :fifteen_minute_rate, :mean_rate,
+            :min, :max, :mean, :stddev
+          ], [
+            :median, :get_95th_percentile
+          ]
+        when Metriks::Histogram
+          send_metric name, 'histogram', metric, [
+            :count, :min, :max, :mean, :stddev
+          ], [
+            :median, :get_95th_percentile
+          ]
+        end
+      end
+    end
+
+    def send_metric(name, type, metric, keys, snapshot_keys = [])
+      keys.each do |key|
+        @client << @default_event.merge(
+          :service => "#{name} #{key}",
+          :metric => metric.send(key),
+          :tags => [type]
+        )
+      end
+
+      unless snapshot_keys.empty?
+        snapshot = metric.snapshot
+        snapshot_keys.each do |key|
+          @client << @default_event.merge(
+            :service => "#{name} #{key}",
+            :metric => snapshot.send(key),
+            :tags => [type]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/metriks/simple_moving_average.rb

@@ -0,0 +1,60 @@
+require 'atomic'
+
+module Metriks
+  class SimpleMovingAverage
+    INTERVAL = 5.0
+    SECONDS_PER_MINUTE = 60.0
+
+    ONE_MINUTE      = 1
+    FIVE_MINUTES    = 5
+    FIFTEEN_MINUTES = 15
+
+    def self.new_m1
+      new(ONE_MINUTE * SECONDS_PER_MINUTE, INTERVAL)
+    end
+
+    def self.new_m5
+      new(FIVE_MINUTES * SECONDS_PER_MINUTE, INTERVAL)
+    end
+
+    def self.new_m15
+      new(FIFTEEN_MINUTES * SECONDS_PER_MINUTE, INTERVAL)
+    end
+
+    def initialize(duration, interval)
+      @interval = interval
+      @duration = duration
+
+      @values = Array.new((duration / interval).to_i) { Atomic.new(nil) }
+      @index  = Atomic.new(0)
+    end
+
+    def clear
+      @values.each do |value|
+        value.value = nil
+      end
+      @index.value = 0
+    end
+
+    def update(value)
+      @values[@index.value].update { |v| v ? v + value : value }
+    end
+
+    def tick
+      @index.update { |v| v < @values.length - 1 ? v + 1 : 0 }
+    end
+
+    def rate
+      num, count = 0.0, 0.0
+
+      @values.each do |value|
+        if v = value.value
+          num   += v
+          count += 1
+        end
+      end
+
+      num / count / @interval.to_f
+    end
+  end
+end