onering-report 0.6.5

data/lib/facter/onering_properties_zfs.rb

@@ -0,0 +1,174 @@
+if Facter::Util::Resolution.which("zpool")
+  def sz_to_bytes(sz)
+    case sz[-1].chr
+    when 'K'
+      rv = sz[0..-2].to_f * (1024)
+    when 'M'
+      rv = sz[0..-2].to_f * (1024 ** 2)
+    when 'G'
+      rv = sz[0..-2].to_f * (1024 ** 3)
+    when 'T'
+      rv = sz[0..-2].to_f * (1024 ** 4)
+    when 'P'
+      rv = sz[0..-2].to_f * (1024 ** 5)
+    when 'E'
+      rv = sz[0..-2].to_f * (1024 ** 6)
+    when 'Z'
+      rv = sz[0..-2].to_f * (1024 ** 7)
+    when 'Y'
+      rv = sz[0..-2].to_f * (1024 ** 8)
+    else
+      rv = sz[0..-2].to_f
+    end
+
+    rv.to_i
+  end
+
+  zfs = {
+    :filesystems => [],
+    :pools       => [],
+    :snapshots   => []
+  }
+
+
+# =============================================================================
+# POOLS
+  Facter::Util::Resolution.exec("zpool list -H").to_s.lines.each do |line|
+    pool, size, allocated, free, used_perc, dedup, health, altroot = line.strip.split(/\s+/)
+    zfs_pool = {
+      :name      => pool,
+      :status    => health.downcase,
+      :size      => {
+        :total        => sz_to_bytes(size),
+        :allocated    => sz_to_bytes(allocated),
+        :free         => sz_to_bytes(free),
+        :used         => (sz_to_bytes(size) - sz_to_bytes(free)),
+        :percent_used => used_perc.delete('%').to_f
+      },
+      :deduplication_factor => dedup.delete('x').to_f,
+      :virtual_devices => {}
+    }
+
+    zfs_pool[:mountpoint] = altroot if altroot != '-'
+    vdevs = {}
+    current_vdev = nil
+
+  # get vdevs/devices
+    Facter::Util::Resolution.exec("zpool status -v #{pool}").to_s.lines.each do |line|
+      if line =~ /^\s*([a-z]+):\s+(.*)$/
+        case $1
+        when 'scan'
+        # scrub output
+          if $2 =~ /scrub repaired ([0-9]+) in ((?:[0-9]+d)?(?:[0-9]+h)?(?:[0-9]+m)) with ([0-9]+) errors on (.*)$/
+            zfs_pool[:scrub] ||= {}
+            zfs_pool[:scrub][:repaired]     = $1.to_i
+            zfs_pool[:scrub][:errors]       = $3.to_i
+            zfs_pool[:scrub][:completed_at] = DateTime.parse($4).strftime("%Y-%m-%d %H:%M:%S %z")
+          end
+        end
+
+    # vdev line
+      elsif line =~ /^\t  ([a-z0-9]+)(?:-([0-9]+))\s+([A-Z]+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s*$/
+        current_vdev = "#{$1}-#{$2}"
+        vdevs[current_vdev] = {
+          :name    => "#{$1}-#{$2}",
+          :type    => $1.to_sym,
+          :number  => $2.to_i,
+          :status  => $3.downcase,
+          :errors  => {
+            :read     => $4.to_i,
+            :write    => $5.to_i,
+            :checksum => $6.to_i
+          },
+          :devices => []
+        }
+
+    # device line
+      elsif line =~ /^\t    ([a-zA-Z0-9\-\_]+)\s+([A-Z]+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s*$/
+        if File.symlink?("/dev/disk/by-id/#{$1}")
+          dev = File.expand_path(File.readlink("/dev/disk/by-id/#{$1}"), "/dev/disk/by-id")
+        elsif File.exists?("/dev/#{$1}")
+          dev = "/dev/#{$1}"
+        end
+
+        vdevs[current_vdev][:devices] << {
+          :name    => $1,
+          :device  => dev,
+          :errors  => {
+            :read     => $2.to_i,
+            :write    => $3.to_i,
+            :checksum => $4.to_i
+          }
+        }
+      end
+    end
+
+    vdevs.each do |name, devs|
+      zfs_pool[:virtual_devices][name.split('-').first.to_sym] ||= []
+      zfs_pool[:virtual_devices][name.split('-').first.to_sym] << devs
+    end
+
+    zfs[:pools] << zfs_pool
+  end
+
+
+
+
+# =============================================================================
+# FILESYSTEMS
+  Facter::Util::Resolution.exec("zfs list -H").to_s.lines.each do |line|
+    filesystem, used, available, referenced, mountpoint = line.strip.split(/\s+/)
+
+    zfs_filesystem = {
+      :name       => filesystem,
+      :mountpoint => mountpoint,
+      :properties => {},
+      :snapshots  => [],
+      :size      => {
+        :used         => sz_to_bytes(used),
+        :free         => sz_to_bytes(available)
+      }
+    }
+
+  # get properties
+    Facter::Util::Resolution.exec("zfs get all -H #{filesystem}").to_s.lines.each do |line|
+      fs, property, value, source = line.strip.split(/\t/)
+
+      value = case value
+      when 'off'                             then false
+      when 'on'                              then true
+      when 'none'                            then nil
+      when /^[0-9]+(?:\.[0-9]+)?[KMGTPEZY]$/ then sz_to_bytes(value)
+      when /^[0-9]+$/                        then value.to_i
+      when /^[0-9]+\.[0-9]+$/                then value.to_f
+      when /^[0-9]+\.[0-9]+x$/               then value.delete('x').to_f
+      else value
+      end
+
+      zfs_filesystem[:properties][property.to_sym] = value
+    end
+
+    zfs[:filesystems] << zfs_filesystem
+  end
+
+
+# =============================================================================
+# SNAPSHOTS
+  Facter::Util::Resolution.exec("zfs list -H -t snapshot").to_s.lines.each do |line|
+    name, used, available, referenced, mountpoint = line.strip.split(/\s+/)
+    mountpoint = nil if mountpoint == '-'
+
+    zfs[:snapshots] << {
+      :name       => name,
+      :used       => sz_to_bytes(used),
+      :available  => sz_to_bytes(available),
+      :referenced => sz_to_bytes(referenced),
+      :mountpoint => mountpoint
+    }
+  end
+
+
+  Facter.add("zfs") do
+    setcode{ zfs }
+  end
+end

data/lib/reporter/default/properties_chef.rb

@@ -0,0 +1,15 @@
+# Onering Collector - Chef Properties plugin
+#   provides collection of Chef metadata
+#
+report do
+  chef = {
+    :name        => Facter.value('chef_nodename'),
+    :environment => Facter.value('chef_environment'),
+    :@run_list   => Facter.value('chef_runlist'),
+    :enabled     => Facter.value('chef_enabled'),
+    :version     => Facter.value('chef_version'),
+    :last_ran_at => (Time.at(Facter.value('chef_lastrun')).strftime('%Y-%m-%d %H:%M:%S %z') rescue nil)
+  }.reject{|k,v| v === nil }
+
+  property :chef, chef unless chef.empty?
+end

data/lib/reporter/default/properties_facter.rb

@@ -0,0 +1,51 @@
+# Onering Collector - Facter Properties plugin
+#   provides a configurable list of Facter facts that should be sent to the
+#   Onering API
+#
+#   Properties defined in /etc/onering/facter.list
+#
+
+report do
+  def cleanup_dirty_values(k, v)
+    return case k
+    when 'mbserial' then v.to_s.gsub(/(^\.+|\.+$)/,'').gsub('.','-')
+    else (v.strip.chomp rescue v)
+    end
+  end
+
+  if defined?(Facter)
+  # get a list of Facter attributes to list
+    local_list = File.join(File.dirname(File.dirname(File.dirname(__FILE__))),'etc','facter.list')
+
+    facts = [
+      local_list,
+      "/etc/onering/facter.list"
+    ].collect{|file|
+      IO.readlines(file) if File.exists?(file)
+    }.flatten.compact.uniq
+
+
+    facts.each do |line|
+      Onering::Logger.debug3("-> Facter Line: #{line.inspect}", "Onering::Reporter")
+
+    # strip whitespace/kill newline
+      line.strip!
+      line.chomp!
+      next if line.empty?
+      line = line.downcase
+
+      unless line =~ /^#/
+        begin
+          line = line.split(':')
+          key = (line.length == 1 ? line.first : line.last)
+          val = cleanup_dirty_values(key, Facter.value(line.first))
+
+          property(key.to_sym, val)
+        rescue Exception => e
+          Onering::Logger.debug(e.message, "onering-report-plugins/properties_facter/#{e.class.name}")
+          next
+        end
+      end
+    end
+  end
+end

data/lib/reporter/default/properties_haproxy.rb

@@ -0,0 +1,8 @@
+# Onering Collector - HAProxy
+#   provides data on HAProxy services
+#
+
+report do
+  haproxy = Facter.value('haproxy')
+  property :@haproxy, haproxy unless haproxy.nil?
+end

data/lib/reporter/default/properties_ipmi.rb

@@ -0,0 +1,10 @@
+# Onering Collector - IPMI plugin
+#   provides collection of IPMI data using vendor tools
+#
+
+report do
+  property :ipmi_ip,         Facter.value('ipmi_ip')
+  property :ipmi_netmask,    Facter.value('ipmi_netmask')
+  property :ipmi_gateway,    Facter.value('ipmi_gateway')
+  property :ipmi_macaddress, Facter.value('ipmi_macaddress')
+end

data/lib/reporter/default/properties_network.rb

@@ -0,0 +1,63 @@
+report do
+  interfaces = {}
+  ips = []
+
+  Facter.value('network_interfaces').each do |iface|
+    iface = iface.to_sym
+    next if [:dummy0, :lo, :sit0].include?(iface)
+    interfaces[iface] ||= {}
+
+    mac = (Facter.value("macaddress_#{iface}").upcase rescue nil)
+    mtu = (Integer(Facter.value("mtu_#{iface}")) rescue nil)
+
+    interfaces[iface][:name] = iface
+    interfaces[iface][:mac] = mac if mac
+    interfaces[iface][:mtu] = mtu if mtu
+
+    ips << Facter.value("ipaddress_#{iface}")
+
+    addresses = [{
+      :ip       => Facter.value("ipaddress_#{iface}"),
+      :netmask  => Facter.value("netmask_#{iface}")
+    }.reject{|k,v| v.nil? }]
+
+    interfaces[iface][:addresses] = addresses unless addresses.empty? or addresses.reject{|i| i.empty? }.empty?
+
+  # LLDP autodiscovery
+    switch = {
+      :name         => Facter.value("lldp_switch_#{iface}"),
+      :port         => Facter.value("lldp_port_#{iface}"),
+      :speed        => Facter.value("lldp_speed_#{iface}"),
+      :duplex       => Facter.value("lldp_duplex_#{iface}"),
+      :port_name    => Facter.value("lldp_port_name_#{iface}"),
+      :port_mac     => Facter.value("lldp_port_mac_#{iface}"),
+      :ip           => Facter.value("lldp_management_ip_#{iface}"),
+      :chassis_mac  => Facter.value("lldp_chassis_mac_#{iface}"),
+      :vlan         => Facter.value("lldp_vlan_#{iface}"),
+      :tagged_vlans => Facter.value("lldp_tagged_vlans_#{iface}")
+    }.reject{|k,v| v.nil? }
+
+
+  # Bonding configuration
+
+  # slaves
+    master = Facter.value("bonding_master_#{iface}")
+    interfaces[iface][:master] = master if master
+
+  # masters
+    bond = {
+      :arp_ip_target => Facter.value("bonding_arp_ip_target_#{iface}")
+    }.reject {|k,v| v.nil? }
+
+
+  # conditionally add applicable subsections
+    interfaces[iface][:switch]  = switch unless switch.empty?
+    interfaces[iface][:bonding] = bond unless bond.empty?
+  end
+
+  property :network, {
+    :@ip         => ips,
+    :@interfaces => interfaces.values,
+    :@sockets    => Facter.value('netstat')
+  }
+end

data/lib/reporter/default/properties_ohai.rb

@@ -0,0 +1,62 @@
+# Onering Collector - Ohai Properties plugin
+#   provides a configurable list of Ohai attributes that should be sent to the
+#   Onering API
+#
+#   Properties defined in /etc/onering/ohai.list
+#
+
+report do
+  if defined?(Ohai)
+    def cleanup_dirty_values(k, v)
+      return case k
+      when 'mbserial' then v.to_s.gsub(/(^\.+|\.+$)/,'').gsub('.','-')
+      else v
+      end
+    end
+
+    # get a list of ohai attributes to list
+    if File.exists?("/etc/onering/ohai.list")
+      IO.readlines("/etc/onering/ohai.list").each do |line|
+      # trip whitespace/kill newline
+        line.strip!
+        line.chomp!
+        next if line.empty?
+        line = line.downcase
+
+        unless line =~ /^#/
+          begin
+            parts = line.split(".")
+            root = @ohai
+
+            parts.each do |part|
+              part = part.split(':')
+              key = part.first
+              alt = part.last
+
+              if root[key]
+                if root[key].is_a?(Hash)
+                  root = root[key]
+                  next
+                else
+                  val = [*root[key]].collect{|i| i.strip.chomp rescue i }
+                  val = val.first if val.length == 1
+                  val = cleanup_dirty_values(alt, val)
+                  val.strip! if val.is_a?(String)
+
+                # set property value
+                  property alt, val
+                  break
+                end
+              else
+                break
+              end
+            end
+          rescue Exception => e
+            Onering::Logger.warn("Error occurred gathering Ohai facts: #{e.class.name} - #{e.message}", "onering-report-plugins/properties_ohai")
+            next
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reporter/default/properties_openvz.rb

@@ -0,0 +1,12 @@
+# Onering Collector - OpenVZ Properties plugin
+#   provides collection of OpenVZ metadata
+#
+report do
+  vz_containers  = Facter.value('openvz_containers')
+  vz = {}
+
+# OpenVZ host
+  vz[:@guests] = vz_containers if vz_containers
+
+  property :openvz, vz unless vz.empty?
+end

data/lib/reporter/default/properties_physical.rb

@@ -0,0 +1,10 @@
+# Onering Collector - Physical Properties plugin
+#   provides collection of hardware location data using vendor tools
+#
+
+report do
+  property :site,            Facter.value('site')
+  property :environment,     Facter.value('environment')
+  property :slot,            Facter.value('slot')
+  property :virtual,         (Facter.value('is_virtual').to_s == 'true' ? true : false)
+end

data/lib/reporter/default/properties_services.rb

@@ -0,0 +1,6 @@
+# Onering Collector - Service List
+#   provides list of certain services that are running on a machine
+#
+report do
+  property :@services, Facter.value('services')
+end

data/lib/reporter/default/properties_system_cpu.rb

@@ -0,0 +1,30 @@
+report do
+# ------------------------------------------------------------------------------
+# cpu
+#
+  stats_cpu = {
+    :count => 0,
+    :processors => []
+  }
+
+  current_cpu = nil
+
+  File.open("/proc/cpuinfo").each do |line|
+    case line
+    when /processor\s+:\s(.+)/
+      current_cpu = $1.to_i
+      stats_cpu[:count] += 1
+      stats_cpu[:processors][current_cpu] = {
+        :number => current_cpu
+      }
+    when /cpu MHz\s+:\s(.+)/
+      stats_cpu[:processors][current_cpu][:speed] = $1.to_f
+    end
+  end
+
+  stat :cpu, ({
+    'count'    => Facter.value('processorcount').to_i,
+    'physical' => Facter.value('physicalprocessorcount').to_i,
+    'speed'    => stats_cpu[:processors].collect{|i| i[:speed] }.compact.uniq.sort{|a,b| a.to_f <=> b.to_f }.last.to_f
+  } rescue nil)
+end

data/lib/reporter/default/properties_system_disk_block.rb

@@ -0,0 +1,35 @@
+report do
+# ------------------------------------------------------------------------------
+# block devices
+#
+  blocks = []
+
+  Facter.value('blockdevices').to_s.split(/\W+/).each do |dev|
+
+    block = {
+      :name   => dev,
+      :device => (File.exists?("/dev/#{dev}") ? "/dev/#{dev}" : nil)
+    }
+
+    if File.directory?("/sys/block/#{dev}")
+      block[:vendor]     = (%x{cat /sys/block/#{dev}/device/vendor 2> /dev/null}.to_s.strip.chomp rescue nil)
+      block[:model]      = (%x{cat /sys/block/#{dev}/device/model 2> /dev/null}.to_s.strip.chomp rescue nil)
+      block[:size]       = ((Integer(%x{cat /sys/block/#{dev}/size 2> /dev/null}.to_s.strip.chomp) * 512) rescue nil)
+      block[:removable]  = (%x{cat /sys/block/#{dev}/removable 2> /dev/null}.to_s.chomp.strip == '1' rescue nil)
+      block[:readonly]   = (%x{cat /sys/block/#{dev}/ro 2> /dev/null}.to_s.chomp.strip == '1' rescue nil)
+      block[:solidstate] = (%x{cat /sys/block/#{dev}/queue/rotational 2> /dev/null}.to_s.chomp.strip == '0' rescue nil)
+      block[:sectorsize] = {}
+
+      %w{
+        logical
+        physical
+      }.each do |s|
+        block[:sectorsize][s.to_sym] = (Integer(%x{cat /sys/block/#{dev}/queue/#{s}_block_size 2> /dev/null}.chomp.strip) rescue nil)
+      end
+    end
+
+    blocks << block.compact
+  end
+
+  stat 'disk.@block', blocks
+end

data/lib/reporter/default/properties_system_disk_lvm.rb

@@ -0,0 +1,73 @@
+report do
+# ------------------------------------------------------------------------------
+# LVM
+#
+  vg = {}
+
+# volume groups
+  Facter::Util::Resolution.exec("vgdisplay -c 2> /dev/null").to_s.lines.each do |line|
+    line = line.strip.chomp.split(':')
+
+    vg[line[0]] = {
+      :name    => line[0],
+      :uuid    => line[16],
+      :size    => (line[11].to_i*1024),
+      :extents => {
+        :size      => (line[12].to_i * 1024),
+        :total     => line[13].to_i,
+        :allocated => line[14].to_i,
+        :free      => line[15].to_i
+      },
+      :volumes => [],
+      :disks => []
+    }
+  end
+
+# logical volumes
+  Facter::Util::Resolution.exec("lvdisplay -c 2> /dev/null").to_s.lines.each do |line|
+    line = line.strip.chomp.split(':')
+
+    unless vg[line[1]].nil?
+      vg[line[1]][:volumes] << {
+        :name    => line[0],
+        :sectors => line[6].to_i,
+        :extents => line[7].to_i,
+        :size    => (vg[line[1]][:extents][:size] * line[7].to_i)
+      }
+    end
+  end
+
+
+# physical volumes
+  Facter::Util::Resolution.exec("pvdisplay -c 2> /dev/null").to_s.lines.each do |line|
+    line = line.strip.chomp.split(':')
+
+    unless vg[line[1]].nil?
+      vg[line[1]][:disks] << {
+        :name    => line[0],
+        :uuid    => line[11],
+        :size    => (line[8].to_i * (line[7].to_i * 1024)),  # See Note 1 below
+        :extents => {
+          :size      => (line[7].to_i * 1024),
+          :total     => line[8].to_i,
+          :allocated => line[10].to_i,
+          :free      => line[9].to_i
+        }
+      }
+
+    # the output of certain versions of pvdisplay -c reports a blatantly incorrect
+    # physical volume total size.  the workaround is to calculate the actual total size
+    # via (total extents * extent size)
+    #
+    # this may or may not be GPT related
+    #
+    end
+  end
+
+  lvm = {}
+  lvm = {
+    :groups => vg.values
+  } unless vg.values.empty?
+
+  stat 'disk.@lvm', lvm unless lvm.empty?
+end

data/lib/reporter/default/properties_system_disk_mounts.rb

@@ -0,0 +1,46 @@
+report do
+# ------------------------------------------------------------------------------
+# mounts
+#
+  mounts = {}
+  current_dev = nil
+
+  uuids = Hash[Dir["/dev/disk/by-uuid/*"].collect{|i|
+    [File.expand_path(File.readlink(i), File.dirname(i)), File.basename(i)]
+  }]
+
+  File.read("/etc/mtab").lines.each do |line|
+    dev,mount,fstype,flags,dump,pass = line.split(/\s+/)
+
+    mounts[dev] = {
+      :mount      => mount,
+      :device     => dev,
+      :filesystem => fstype,
+      :flags      => flags.split(/\s*,\s*/),
+      :uuid       => uuids[dev]
+    }.compact
+  end
+
+# logical space utilization
+  Facter::Util::Resolution.exec("df 2> /dev/null").to_s.lines.each do |line|
+    next if line =~ /^Filesystem/
+    parts = line.split(/\s+/)
+
+    if parts.length == 1
+      current_dev = parts.first
+      next
+
+    else
+      dev,kblk,used,free,percent,mount = parts
+      dev = current_dev if dev.empty?
+      next unless mounts[dev] and mounts[dev].is_a?(Hash)
+
+      mounts[dev][:used] = (used.to_i * 1024)
+      mounts[dev][:available] = (free.to_i * 1024)
+      mounts[dev][:total] = (mounts[dev][:available] + mounts[dev][:used])
+      mounts[dev][:percent_used] = percent.delete('%').to_i
+    end
+  end
+
+  stat 'disk.@mounts', (Hash[mounts.select{|k,v| k =~ /^\/dev\/((h|s|xv|v)d|mapper|vgc)/ }].values rescue nil)
+end

data/lib/reporter/default/properties_system_disk_smart.rb

@@ -0,0 +1,3 @@
+report do
+  stat 'disk.@smart', Facter.value('smart')
+end