salus 0.1.2

data/lib/salus/logging.rb

@@ -0,0 +1,15 @@
+require "logger"
+
+module Salus
+  # Loosely based on code from https://github.com/ruby-concurrency/concurrent-ruby/
+  module Logging
+    include Logger::Severity
+
+    def log(level, message = nil, progname = nil, &block)
+      (@logger || Salus.logger).add level, message, progname, &block
+    rescue => error
+      $stderr.puts "Failed to log #{[level, progname, message, block]}\n" +
+        "#{error.message} (#{error.class})\n#{error.backtrace.join "\n"}"
+    end
+  end
+end

data/lib/salus/metric.rb

@@ -0,0 +1,173 @@
+module Salus
+  class Fifo
+    extend Forwardable
+    def_delegators :@data, :[], :each, :length, :empty?, :clear, :last, :first, :hash, :map
+
+    def initialize(maxlen)
+      @maxlen = maxlen
+      @data   = []
+    end
+
+    def <<(value)
+      @data << value
+      @data.shift if @data.length > @maxlen
+      self
+    end
+  end
+
+  class Metric
+    include Logging
+    include Lockable
+    STORAGE_DEPTH = 2
+
+    Value = Struct.new(:value, :timestamp, :ttl) do
+      def expired?(ts=nil)
+        return false if ttl.nil?
+        ts ||= Time.now.to_f
+        ts > (timestamp + ttl)
+      end
+    end
+
+    def self.inherited(subclass)
+      @@descendants ||= []
+      @@descendants << subclass
+    end
+
+    def self.descendants
+      @@descendants || []
+    end
+
+    def initialize(defaults={})
+      @values = Fifo.new(self.class::STORAGE_DEPTH)
+      @opts   = defaults.clone
+      @attributes = {}
+      @last_calced_value = nil
+      @last_calced_ts    = nil
+      @needs_update      = true
+
+      option :mute, TrueClass, FalseClass
+      option :value, Numeric
+      option :timestamp, Numeric
+      option :ttl, Numeric
+
+      @opts.each do |k, v|
+        validate(k, v)
+      end
+    end
+
+    def mute?
+      synchronize { @opts[:mute] || false }
+    end
+
+    def push(opts={}, &block)
+      opts = {} unless opts.is_a?(Hash)
+
+      synchronize do
+        opts.each do |k, v|
+          validate(k, v)
+          @opts[k] = v unless [:value, :ttl, :timestamp].include?(k)
+        end
+
+        if block_given?
+          v = begin
+            yield
+          rescue Exception => e
+            log DEBUG, e
+            nil
+          end
+          validate(:value, v)
+          opts[:value] = v
+        end
+
+        @values << Value.new(opts[:value], opts[:timestamp] || Time.now.to_f, opts[:ttl] || @opts[:ttl])
+        @needs_update = true
+      end
+    end
+
+    def timestamp
+      synchronize do
+        calc if @needs_update
+        @last_calced_ts
+      end
+    end
+
+    def value
+      synchronize do
+        calc if @needs_update
+        @last_calced_value
+      end
+    end
+
+    def ttl
+      synchronize do
+        @values.empty? ? nil : @values.last.ttl
+      end
+    end
+
+    def expired?(ts=nil)
+      synchronize do
+        if @values.empty?
+          true
+        else
+          @values.last.expired?(ts)
+        end
+      end
+    end
+
+    def load(data)
+      return if data.nil?
+      return if data.empty?
+      return unless data.key?(:values)
+      synchronize do
+        if data.key?(:mute)
+          @opts[:mute] = data[:mute]
+        end
+        data[:values].each do |v|
+          @values << Value.new(v[:value], v[:timestamp], v[:ttl])
+        end
+        @needs_update  = true
+      end
+    end
+
+    def save
+      to_h
+    end
+
+    def to_h
+      return {} if @values.empty?
+      synchronize do
+        {
+          type: self.class.name.split('::').last,
+          mute: mute?,
+          values: @values.map { |x| x.to_h }
+        }
+      end
+    end
+
+    protected
+    def option(key, *types)
+      @attributes[key] = types
+    end
+
+    def validate(key, value)
+      return if value.nil?
+      return unless @attributes.key?(key)
+      unless @attributes[key].any? { |t| value.is_a?(t) }
+        raise ArgumentError, "Option #{key} should be #{@attributes[key].join(" or ")}"
+      end
+      value
+    end
+
+    def calc
+      if @values.empty?
+        @last_calced_ts    = nil
+        @last_calced_value = nil
+        @needs_update      = true
+      else
+        @last_calced_ts    = @values.last.timestamp
+        @last_calced_value = @values.last.value
+        @needs_update      = false
+      end
+    end
+  end
+end

data/lib/salus/metric/absolute.rb

@@ -0,0 +1,21 @@
+module Salus
+  class Absolute < Metric
+    def calc
+      super
+      @last_calced_value = nil
+
+      if @values.length < STORAGE_DEPTH
+        return
+      elsif @values[0].expired?(@values[1].timestamp)
+        return
+      elsif !@values[1].value.is_a?(Numeric)
+        return
+      end
+
+      @last_calced_value = begin
+        dt = (@values[1].timestamp - @values[0].timestamp)
+        (dt == 0) ? nil : (@values[1].value / dt)
+      end
+    end
+  end
+end

data/lib/salus/metric/counter.rb

@@ -0,0 +1,41 @@
+module Salus
+  class Counter < Metric
+    INT32_MAX = 2**32
+    def initialize(defaults={})
+      super(defaults)
+      option :maximum, Numeric
+      validate(:maximum, @opts[:maximum]) if @opts.key?(:maximum)
+    end
+
+    def calc
+      super
+      @last_calced_value = nil
+
+      if @values.length < STORAGE_DEPTH
+        return
+      elsif @values[0].expired?(@values[1].timestamp)
+        return
+      elsif !@values[0].value.is_a?(Numeric)
+        return
+      elsif !@values[1].value.is_a?(Numeric)
+        return
+      end
+
+      @last_calced_value = begin
+        dt = (@values[1].timestamp - @values[0].timestamp)
+        dv = if @values[1].value < @values[0].value
+          w = @values[0].value < INT32_MAX ? 32 : 64
+          (2**w - @values[0].value + @values[1].value)
+        else
+          (@values[1].value - @values[0].value)
+        end
+        r = (dt == 0) ? nil : (dv / dt)
+        if @opts.key?(:maximum) && !r.nil? && r > @opts[:maximum]
+          nil
+        else
+          r
+        end
+      end
+    end
+  end
+end

data/lib/salus/metric/derive.rb

@@ -0,0 +1,36 @@
+module Salus
+  class Derive < Metric
+    def initialize(defaults={})
+      super(defaults)
+      option :minimum, Numeric
+      validate(:minimum, @opts[:minimum]) if @opts.key?(:minimum)
+    end
+
+    protected
+    def calc
+      super
+      @last_calced_value = nil
+
+      if @values.length < STORAGE_DEPTH
+        return
+      elsif @values[0].expired?(@values[1].timestamp)
+        return
+      elsif !@values[0].value.is_a?(Numeric)
+        return
+      elsif !@values[1].value.is_a?(Numeric)
+        return
+      end
+
+      @last_calced_value = begin
+        dt = (@values[1].timestamp - @values[0].timestamp)
+        dv = (@values[1].value - @values[0].value)
+        r = (dt == 0) ? nil : (dv / dt)
+        if @opts.key?(:minimum) && !r.nil? && r < @opts[:minimum]
+          nil
+        else
+          r
+        end
+      end
+    end
+  end
+end

data/lib/salus/metric/gauge.rb

@@ -0,0 +1,5 @@
+module Salus
+  class Gauge < Metric
+    STORAGE_DEPTH = 1
+  end
+end

data/lib/salus/metric/text.rb

@@ -0,0 +1,9 @@
+module Salus
+  class Text < Metric
+    STORAGE_DEPTH = 1
+    def initialize(defaults={})
+      super(defaults)
+      option :value, Symbol, String
+    end
+  end
+end

data/lib/salus/renderer.rb

@@ -0,0 +1,8 @@
+require "json"
+require "salus/renderer/base"
+require "salus/renderer/block"
+require "salus/renderer/stdout"
+require "salus/renderer/collectd"
+require "salus/renderer/graphite"
+require "salus/renderer/zabbixbulk"
+require "salus/renderer/zabbixsender"

data/lib/salus/renderer/base.rb

@@ -0,0 +1,50 @@
+module Salus
+  class BaseRenderer
+    include Logging
+    def self.inherited(subclass)
+      @@descendants ||= []
+      @@descendants << subclass
+    end
+
+    def self.descendants
+      @@descendants || []
+    end
+
+    def initialize(opts={})
+      @separator  = opts.fetch(:separator, '.')
+      @allow_mute = opts.fetch(:allow_mute, false)
+    end
+
+    def render(data)
+      # Implement renderer
+      raise "Unimplemented"
+    end
+
+    def iterate(node, prefix="", &block)
+      case node
+      when Hash
+        node.each do |name, item|
+          iterate(item, join_name(prefix, name), &block)
+        end
+      when Salus::Group
+        node.each(@allow_mute) do |name, metric|
+          iterate(metric, join_name(prefix, name), &block)
+        end
+        if node.has_subgroups?
+          node.groups.each do |name, group|
+            iterate(group, join_name(prefix, name), &block)
+          end
+        end
+      when Salus::Metric
+        block.call(prefix, node) unless node.expired?
+      else
+        log WARN, "Unknown node type #{node.class}"
+      end
+    end
+
+    protected
+    def join_name(prefix, name)
+      prefix + (prefix.empty? ? '' : @separator) + name
+    end
+  end
+end

data/lib/salus/renderer/block.rb

@@ -0,0 +1,13 @@
+module Salus
+  class BlockRenderer < BaseRenderer
+    def initialize(opts={}, &block)
+      super(opts)
+      raise ArgumentError, "Block must be supplied" unless block_given?
+      @proc = block
+    end
+
+    def render(data)
+      instance_exec(data, &@proc)
+    end
+  end
+end

data/lib/salus/renderer/collectd.rb

@@ -0,0 +1,21 @@
+module Salus
+  class CollectdRenderer < BaseRenderer
+    def initialize(opts={})
+      opts[:separator] = opts.fetch(:separator, '/')
+      super(opts)
+    end
+
+    def render(data)
+      hostname = ENV.fetch('COLLECTD_HOSTNAME', 'localhost')
+      options  = ENV.key?('COLLECTD_INTERVAL') ? "interval=#{ENV['COLLECTD_INTERVAL']} " : ''
+      iterate(data) do |name, metric|
+        # Text metrics are unsupported
+        next if metric.is_a? Salus::Text
+        unless metric.timestamp.nil?
+          # Effectively all salus metrics are gauges for collectd, with exception to text
+          STDOUT.puts "PUTVAL #{hostname}#{@separator}#{name} #{options}#{metric.timestamp.to_i}:#{metric.value.nil? ? 'U' : metric.value}"
+        end
+      end
+    end
+  end
+end

data/lib/salus/renderer/graphite.rb

@@ -0,0 +1,14 @@
+module Salus
+  class GraphiteRenderer < BaseRenderer
+    def render(data)
+      iterate(data) do |name, metric|
+        # Text metrics are unsupported
+        next if metric.is_a? Salus::Text
+        # Nil value means nothing collected, so just ignore it
+        unless metric.value.nil? || metric.timestamp.nil?
+          STDOUT.puts "#{name} #{metric.value} #{metric.timestamp.to_i}"
+        end
+      end
+    end
+  end
+end

data/lib/salus/renderer/stdout.rb

@@ -0,0 +1,18 @@
+module Salus
+  class StdoutRenderer < BaseRenderer
+    def initialize(opts={})
+      super(opts)
+      @precision = opts.fetch(:precision, 2)
+    end
+
+    def render(data)
+      iterate(data) do |name, metric|
+        value = metric.value
+        unless metric.is_a?(Salus::Text)
+          value = "%.#{@precision}f" % value unless value.nil?
+        end
+        STDOUT.puts "[#{Time.at(metric.timestamp)}] #{name} - #{value}" unless metric.timestamp.nil?
+      end
+    end
+  end
+end