newrelic_zfs 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9fdd5091dd94e9ea8d6b2b9ac4a6f856b6a8f8b9
-  data.tar.gz: 4be49358deb4349c9ce20f31cecda0bf79d1e6bf
+  metadata.gz: 1a84c6a5a80661fbb31b730dbb65a8156af454d3
+  data.tar.gz: 7bc403399ec882917003132f15c3461c56b15f69
 SHA512:
-  metadata.gz: 4726fd516e06b68227dbcce1af4cd46c9afa61a3a6dd3f910dd5aadc5673291d587ac221d011481792230ddd7a53b5642236f2acb19b8c573b3eb01d70925b00
-  data.tar.gz: cd7ba440866b75b6fb57ac14a0188b6eb8b94826b9c385baa5f2be0da4b5f9d7cbf3edaea4bdb0ba79825a7c101ed7127e68779d0916ddf7aa5b9778fdc604d5
+  metadata.gz: f77a39debb534c889fcc354fd0a3dffa875cf3b1618b51988aa0c099c1af8e7640b87c5dad0490513612bcc5c0e488261944f1bbb0b1b5eb1bd8307c8177defa
+  data.tar.gz: 86c29b3d2724b6c69efd99a707a6a9c7bac7095b2c64a45b33e9e52fb3338b2116d802bf5da71e1bba0a77277e393acda5413e249bf85f2644cc88ebecbd57cb

data/bin/newrelic_zfs

@@ -6,7 +6,7 @@ require 'bundler/setup'
 require 'newrelic_plugin'
 require 'trollop'
 
-require 'newrelic_zfs'
+require 'collector'
 require 'newrelic_zfs/config'
 
 module ZfsAgent
@@ -18,31 +18,28 @@ module ZfsAgent
     agent_config_options :instance_name, :print_metrics
     agent_human_labels("ZFS Agent") { instance_name }
 
+    def initialize(context, options)
+      puts 'Initializing ZfsAgent'
+      @collector = Collector.new
+      super(context, options)
+    end
+
     def poll_cycle
-      collector = ZFSTools::Collector.new
-      stats = collector.collect_stats
-      health_total = 0
-      stats.each do |stat|
-        if stat.name == 'UnhealthyCount'
-          health_total = health_total + stat.value
-        end
-
-        stat_name = 'ZPools/' + stat.name + '/' + stat.pool_name
-        if print_metrics
-          puts 'Reporting metric named ' + stat_name + ' with value ' + stat.value.to_s + ' and unit ' + stat.unit
-        end
-        report_metric stat_name, stat.unit, stat.value
+      puts 'Starting metrics collection'
+      metrics = @collector.collect_stats
+      puts "#{metrics.length} metrics collected, sending to New Relic"
+      metrics.each do |metric|
+        puts 'Reporting metric named ' + metric.newrelic_name + ' with value ' +
+                 metric.value.to_s + ' and unit ' + metric.unit
       end
 
-      stat_name = 'ZPools/UnhealthyCount'
-      if print_metrics
-        puts 'Reporting metric named ' + stat_name + ' with value ' + health_total.to_s + ' and unit Value'
+      metrics.each do |metric|
+        report_metric metric.newrelic_name, metric.unit, metric.value
       end
-      report_metric stat_name, 'Value', health_total
+      puts 'Finished sending metrics to New Relic'
     end
   end
 
-
   opts = Trollop::options do
     opt :config_file, "Config file", :type => :string
   end
@@ -55,6 +52,4 @@ module ZfsAgent
   NewRelic::Plugin::Config::config_file = config_file_path
   NewRelic::Plugin::Setup.install_agent :zfs, ZfsAgent
   NewRelic::Plugin::Run.setup_and_run
-
-  puts 'Newrelic ZFS Agent started'
 end

data/lib/collector.rb

@@ -0,0 +1,90 @@
+require_relative 'newrelic_zfs/metric'
+require_relative 'newrelic_zfs/processor'
+require_relative 'newrelic_zfs/converter'
+
+class Collector
+
+  def initialize
+    @blacklist = ['Altroot']
+    @summary_metrics = { 'UnhealthyCount' => Metric.method(:sum), 'Capacity' => Metric.method(:mean),
+                         'Size' => Metric.method(:sum) }
+    @processor = Processor.new
+    @converter = Converter.new
+  end
+  def collect_stats
+    metrics = []
+    first = true
+
+    run_command.each_line do |line|
+      if first
+        puts 'Processing as a header line'
+        puts line
+        @processor.process_header_line(line)
+        first = false
+      else
+        puts 'Processing as a metric line'
+        puts line
+        metrics = metrics + @processor.line_to_metrics(line)
+      end
+    end
+
+    puts 'Filtering out blacklist metrics'
+    metrics = metrics.find_all { |metric|
+      !@blacklist.include?(metric.name)
+    }
+
+    #Convert the value first, otherwise adding won't work when calculating summary metrics
+    puts 'Starting to convert metrics'
+    metrics = convert_metrics(metrics)
+    puts 'Finished converting metrics'
+    puts 'Starting to calculate and convert summary metrics'
+    metrics = metrics + convert_metrics(get_summary_metrics(metrics))
+    puts 'Finished calculating and converting summary metrics'
+
+    metrics
+  end
+
+  def get_summary_metrics(metrics)
+    puts 'Started to calculate summary metrics'
+    metrics_hash = {}
+    metrics.each do |metric|
+      puts "Processing metric #{metric.name}"
+      if @summary_metrics.has_key?(metric.name)
+        puts 'Metric is in summmary metrics list, processing it'
+        summary_metric = metrics_hash[metric.name]
+        if summary_metric.nil?
+          puts 'No previous summary metric existed, creating a new one'
+          summary_metric = Metric.new
+          summary_metric.name = metric.name
+          summary_metric.unit = metric.unit
+          summary_metric.aggregate_function = @summary_metrics[metric.name]
+          metrics_hash[metric.name] = summary_metric
+        end
+
+        puts "Adding value #{metric.value} to summary metric #{summary_metric.name}"
+        summary_metric.add_value(metric.value)
+      end
+    end
+
+    puts 'Finished calculating summary metrics'
+    metrics_hash.values
+  end
+
+  def convert_metrics(metrics)
+    metrics.each do |metric|
+      puts "Converting metric name: #{metric.name}"
+      metric.name = @converter.convert_name(metric)
+      puts "Metric name is now: #{metric.name}"
+      puts "Converting metric value #{metric.value}"
+      metric.set_value @converter.convert_value(metric)
+      puts "Value is now: #{metric.value}"
+      puts "Converting metric unit: #{metric.unit}"
+      metric.unit = @converter.convert_unit(metric)
+      puts "Unit is now: #{metric.unit}"
+    end
+  end
+
+  def run_command
+    `zpool list`
+  end
+end

data/lib/newrelic_zfs/converter.rb

@@ -0,0 +1,41 @@
+class Converter
+  def initialize
+    @name_conversions = { :health => 'UnhealthyCount', :cap => 'Capacity'}
+    @value_conversions = { :online => 0, :- => 0}
+    @unit_conversions = { :b => 'bytes', :k => 'kilobytes', :m => 'megabytes',
+                          :g => 'gigabytes', :t => 'terabytes', :p => 'petabytes'}
+    @last_seen_unit = {}
+  end
+
+  def convert_name(metric)
+    _do_convert(metric.name, @name_conversions)
+  end
+
+  def convert_value(metric)
+    converted = _do_convert(metric.raw_value, @value_conversions)
+    Float(converted) rescue 1
+  end
+
+  def convert_unit(metric)
+    converted = _do_convert(metric.unit, @unit_conversions)
+
+    if converted.nil?
+      converted = @last_seen_unit[metric.name]
+    end
+
+    if converted.nil?
+      converted = 'Value'
+    end
+
+    @last_seen_unit[metric.name] = converted
+
+    converted
+  end
+
+  def _do_convert(value, conversion_hash)
+    symbol = value.nil? ? nil : value.downcase.to_sym rescue value
+    converted = conversion_hash[symbol]
+
+    converted.nil? ? value : converted
+  end
+end

data/lib/newrelic_zfs/metric.rb

@@ -0,0 +1,59 @@
+class Metric
+  attr_accessor :pool_name
+  attr_accessor :name
+  attr_accessor :unit
+  attr_reader :count
+  attr_writer :aggregate_function
+
+  def initialize
+    @count = 0
+    @value = 0
+  end
+
+  def is_summary_metric?
+    !@aggregate_function.nil?
+  end
+
+  def add_value(value)
+    if @aggregate_function.nil?
+      @value = value
+    else
+      @value = @value + value rescue value
+      @count = @count + 1
+    end
+  end
+
+  def set_value(value)
+    @value = value
+  end
+
+  def value
+    @aggregate_function.nil? ? @value : @aggregate_function.call(@value, @count)
+  end
+
+  def raw_value
+    @value
+  end
+
+  def newrelic_name
+    if is_summary_metric?
+      "ZPools/#{@name}"
+    else
+      "ZPools/#{@name}/#{@pool_name}"
+    end
+  end
+
+  def self.mean(value, count)
+    if value.nil? || count.nil?
+      0
+    elsif count == 0
+      value
+    else
+      value.to_f / count
+    end
+  end
+
+  def self.sum(value, count)
+    value
+  end
+end

data/lib/newrelic_zfs/processor.rb

@@ -0,0 +1,43 @@
+require_relative 'metric'
+
+class Processor
+  def process_header_line(line)
+    @headers = []
+    line.split(' ').each_with_index do |header, index|
+      @headers[index] = header.capitalize
+    end
+  end
+
+  def line_to_metrics(line)
+    pool_name = nil
+    metrics = []
+    line.split(' ').each_with_index do |value, index|
+      if @headers[index].casecmp('Name') == 0
+        pool_name = value
+      else
+        metric = Metric.new
+        split = split_value_and_unit(value)
+        metric.name = @headers[index]
+        metric.add_value split[0]
+        metric.unit = split[1]
+        metrics << metric
+      end
+    end
+
+    metrics.each { |metric|
+      metric.pool_name = pool_name
+    }
+  end
+
+  def split_value_and_unit(text)
+    match = /\d+\.?\d*/.match(text)
+    #If numeric value
+    if match
+      value = match[0]
+      unit = text.slice(value.length, text.length)
+      [value, unit]
+    else
+      [text, nil]
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: newrelic_zfs
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Tom Reay
@@ -60,15 +60,19 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/newrelic_zfs
-- lib/newrelic_zfs.rb
+- lib/collector.rb
 - lib/newrelic_zfs/config.rb
-homepage: http://rubygems.org/gems/newrelic-zfs
+- lib/newrelic_zfs/converter.rb
+- lib/newrelic_zfs/metric.rb
+- lib/newrelic_zfs/processor.rb
+homepage: https://github.com/tomreay/newrelic_zfs_plugin
 licenses:
 - MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
+- lib/newrelic_zfs
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:

data/lib/newrelic_zfs.rb

@@ -1,116 +0,0 @@
-module ZFSTools
-  class Stat
-    attr_reader :pool_name
-    attr_reader :name
-    attr_reader :unit
-    attr_reader :value
-    
-    def initialize(pool_name, name, unit, value)
-      @pool_name = pool_name
-      @name = name
-      @unit = unit
-      @value = value
-    end
-  end
-  
-  class Pool
-    BLACK_LIST = ['Altroot']
-  
-    attr_accessor :name
-    attr_reader :values
-
-    def initialize() 
-      @values = {}
-    end
-  
-    def add_value(heading, value)
-      if !BLACK_LIST.include?(heading)
-        @values.merge!({ heading => value })
-      end
-    end
-  end
-
-  class Converter
-    UNITS = { 'B' => 'bytes', 'K' => 'kilobytes', 'M' => 'megabytes', 'G' => 'gigabytes', 'T' => 'terabytes', 'P' => 'petabytes'}
-    HEADINGS = { 'Health' => 'UnhealthyCount' }
-    
-    def convert(heading, value) 
-      values = _split(value)
-      return [ _convert(heading, HEADINGS), _convert_d(values[1], UNITS, 'Value'), values[0] ]
-    end
-  
-    def _split(value)
-      match = /\d+\.?\d*/.match(value)
-      #If numeric value
-      if match
-        numeric_part = match[0]
-        unit = value.slice(numeric_part.length, value.length)
-        return [numeric_part, unit]
-      elsif value == 'ONLINE'
-        return [0, '']
-      else
-        return [1, '']
-      end
-    end
-  
-    def _convert_d(value, hash, default)
-      converted = _convert(value, hash)
-      
-      if converted.nil?
-        converted = default
-      end
-      
-      return converted
-    end
-    
-    def _convert(value, hash)
-      converted = hash[value]
-      
-      #If the converted value is null, use the original unit
-      if converted.nil?
-        converted = value
-      end
-    
-      return converted
-    end
-  end
-
-  class Collector
-    CONVERTER = Converter.new
-  
-    def collect_stats()
-      first = true
-      headings = {}
-      pools = []
-  
-      `zpool list`.each_line do |line|
-      #File.open('/Users/tomreay/Documents/workspaceWebApps/newrelic-zfs/list.txt').each_line do |line|
-        pool = Pool.new
-        line.split(' ').each_with_index do |token, index|
-          if first
-            headings.merge!({ index => token.capitalize})
-          else 
-            if headings[index] == 'Name'
-              pool.name = token
-            else
-              pool.add_value(headings[index], token)
-            end
-          end
-        end  
-        first = false
-        pools << pool
-      end
-
-      stats = []
-      pools.each do |pool|
-        pool.values.each do |heading, value|
-          converted = CONVERTER.convert(heading, value)
-          stat = Stat.new(pool.name, converted[0], converted[1], converted[2])
-          stats << stat
-        end
-      end
-      
-      return stats
-    end
-  end
-end