riemann-tools 1.10.0 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecfc9ade5a8ea50dcf495633c6427b14d41b78c04ef436c062491f96f97cbc16
-  data.tar.gz: 4ef67c8726d662c449e545601d3e7fe29d7104edaff39be294ca26e963f8e176
+  metadata.gz: aa81e2c6ea617e2450bdc8456f8665493241b19256be9a5443b6351e5d417ace
+  data.tar.gz: 0eb2bb5e1f6caea452a2babe933acd270840a78fe15520d637b7b3eb1deeb93e
 SHA512:
-  metadata.gz: 1d6b3a8872ffd2f8e73415f1108cb853d04ddf5fcf4fa0a9de81701f993d286f6b9337f3448d54d56d6da4f50f5d2582d29c1d4da18be418dcb5e5b1addd3eab
-  data.tar.gz: 8753726be6f187c0d88cbc8cf08eea6df9d4d5d5996e6d0ac44c5fc7bfe5d5dc648e9c191f9d0691f780d6b5e4a60ef75176f3ead1803e97e1a107e67234eb9c
+  metadata.gz: eccb9331a24c1db7812365ee6c52d811a962b681563237f1e4f196aad7ae59171daaf9548db8792ff8ab548b393a04c00078c8ba59701373f8c452077960cae6
+  data.tar.gz: 75508745d0f31fd2b5457531ae68158f514ca5ac9fa65c64c00c9ceedf67df8644b87bd324ef0aca94527e862c51ad063702ab8be95181723b6c73fefd2c9fb9

data/.github/workflows/ci.yml

@@ -17,7 +17,7 @@ jobs:
       - name: Setup ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: '2.7'
+          ruby-version: '3.1'
           bundler-cache: true
       - name: Run rubocop
         run: bundle exec rubocop
@@ -27,11 +27,12 @@ jobs:
     strategy:
       matrix:
         ruby-version:
-          - 2.6
-          - 2.7
-          - 3.0
-          - 3.1
-          - 3.2
+          - '2.6'
+          - '2.7'
+          - '3.0'
+          - '3.1'
+          - '3.2'
+          - '3.3'
     steps:
       - uses: actions/checkout@v4
       - name: Setup Ruby

data/.gitignore

@@ -6,3 +6,4 @@ pkg/
 .*.swp
 *.log
 lib/riemann/tools/*_parser.tab.rb
+spec/fixtures/test-asn/test-asn

data/.rubocop.yml

@@ -1,14 +1,20 @@
 ---
 AllCops:
+  NewCops: enable
   Exclude:
     - lib/riemann/tools/*_parser.tab.rb
     - vendor/bundle/**/*
+require:
+  - rubocop-rake
+  - rubocop-rspec
 Gemspec/RequiredRubyVersion:
   Enabled: false
 Layout/HashAlignment:
   EnforcedHashRocketStyle: table
 Layout/LineLength:
   Enabled: false
+Lint/EmptyBlock:
+  Enabled: false
 Metrics/AbcSize:
   Enabled: false
 Metrics/BlockLength:
@@ -28,10 +34,22 @@ Naming/MethodParameterName:
     - az # availability zone
     - id
     - lb # load balancer
+RSpec/ExampleLength:
+  Enabled: false
+RSpec/MultipleExpectations:
+  Enabled: false
+RSpec/NamedSubject:
+  Enabled: false
+RSpec/NestedGroups:
+  Enabled: false
+RSpec/SubjectStub:
+  Enabled: false
 Style/Documentation:
   Enabled: false
 Style/HashSyntax:
   EnforcedShorthandSyntax: never
+Style/NegatedIfElseCondition:
+  Enabled: false
 Style/TrailingCommaInArguments:
   EnforcedStyleForMultiline: consistent_comma
 Style/TrailingCommaInArrayLiteral:

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [v1.11.0](https://github.com/riemann/riemann-tools/tree/v1.11.0) (2024-07-07)
+
+[Full Changelog](https://github.com/riemann/riemann-tools/compare/v1.10.0...v1.11.0)
+
+**Implemented enhancements:**
+
+- Add a new `riemann-hwmon` tool for harware monitors [\#297](https://github.com/riemann/riemann-tools/pull/297) ([smortex](https://github.com/smortex))
+- Add support for ignoring IPs by ASN in `riemann-http` [\#295](https://github.com/riemann/riemann-tools/pull/295) ([smortex](https://github.com/smortex))
+- Add support for a minimum TTL for events [\#294](https://github.com/riemann/riemann-tools/pull/294) ([smortex](https://github.com/smortex))
+- Detect and report stray arguments [\#293](https://github.com/riemann/riemann-tools/pull/293) ([smortex](https://github.com/smortex))
+- Add leniency to disk thresholds of `riemann-health` [\#282](https://github.com/riemann/riemann-tools/pull/282) ([smortex](https://github.com/smortex))
+- Add `riemann-tls-check` to monitor TLS certificates [\#253](https://github.com/riemann/riemann-tools/pull/253) ([smortex](https://github.com/smortex))
+
+**Fixed bugs:**
+
+- Minor `riemann-hwmon` improvements [\#298](https://github.com/riemann/riemann-tools/pull/298) ([smortex](https://github.com/smortex))
+- Fix `riemann-nginx` checks selection [\#292](https://github.com/riemann/riemann-tools/pull/292) ([smortex](https://github.com/smortex))
+- Fix `riemann-health` memory reporting when using ZFS on Linux [\#289](https://github.com/riemann/riemann-tools/pull/289) ([smortex](https://github.com/smortex))
+
+**Closed issues:**
+
+- RFC: `riemann-domain-check` to monitor domain name expiration date [\#249](https://github.com/riemann/riemann-tools/issues/249)
+
 ## [v1.10.0](https://github.com/riemann/riemann-tools/tree/v1.10.0) (2024-01-13)
 
 [Full Changelog](https://github.com/riemann/riemann-tools/compare/v1.9.1...v1.10.0)

data/Gemfile

@@ -4,3 +4,25 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in riemann-tools.gemspec
 gemspec
+
+gem 'github_changelog_generator'
+gem 'maxmind-geoip2'
+gem 'racc'
+gem 'rake'
+gem 'rspec'
+gem 'rubocop'
+gem 'rubocop-rake'
+gem 'rubocop-rspec'
+gem 'sinatra'
+gem 'webrick'
+
+if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7.0')
+  # XXX: Needed for Ruby 2.6 compatibility
+  #
+  # With Ruby 2.6 an older version of rakup is installed that cause other gems
+  # to be installed with a legacy version.
+  #
+  # Because rakup is only needed when using rack 3, we can just ignore this
+  # with Ruby 2.6.
+  gem 'rackup'
+end

data/Rakefile

@@ -20,7 +20,7 @@ task :rbuild do
   end
 end
 
-task build: :gen_parser
+Rake::Task['build'].enhance(['gen_parser'])
 
 desc 'Generate parsers'
 task gen_parser: [

data/bin/riemann-hwmon

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
+
+require 'riemann/tools/hwmon'
+
+Riemann::Tools::Hwmon.run

data/bin/riemann-tls-check

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
+
+require 'riemann/tools/tls_check'
+
+Riemann::Tools::TLSCheck.run

data/lib/riemann/tools/apache_status.rb

@@ -18,6 +18,8 @@ module Riemann
       opt :user_agent, 'User-Agent header for HTTP requests', short: :none, default: "#{File.basename($PROGRAM_NAME)}/#{Riemann::Tools::VERSION} (+https://github.com/riemann/riemann-tools)"
 
       def initialize
+        super
+
         @uri = URI.parse("#{opts[:uri]}?auto")
         # Sample Response with ExtendedStatus On
         # Total Accesses: 20643

data/lib/riemann/tools/bench.rb

@@ -11,6 +11,8 @@ module Riemann
       attr_accessor :client, :hosts, :services, :states
 
       def initialize
+        super
+
         @hosts = [nil] + (0...10).map { |i| "host#{i}" }
         @hosts = %w[a b c d e f g h i j]
         @services = %w[test1 test2 test3 foo bar baz xyzzy attack cat treat]
@@ -19,8 +21,8 @@ module Riemann
       end
 
       def evolve(state)
-        m = state[:metric] + (rand - 0.5) * 0.1
-        m = [[0, m].max, 1].min
+        m = state[:metric] + ((rand - 0.5) * 0.1)
+        m = m.clamp(0, 1)
 
         s = case m
             when 0...0.75

data/lib/riemann/tools/consul_health.rb

@@ -20,6 +20,8 @@ module Riemann
       opt :user_agent, 'User-Agent header for HTTP requests', short: :none, default: "#{File.basename($PROGRAM_NAME)}/#{Riemann::Tools::VERSION} (+https://github.com/riemann/riemann-tools)"
 
       def initialize
+        super
+
         @hostname = opts[:consul_host]
         @prefix = opts[:prefix]
         @minimum_services_per_node = opts[:minimum_services_per_node]

data/lib/riemann/tools/dir_files_count.rb

@@ -15,6 +15,8 @@ module Riemann
       opt :alert_on_missing, 'Send a critical metric if the directory is missing?', default: true
 
       def initialize
+        super
+
         @dir = opts.fetch(:directory)
         @service_prefix = opts.fetch(:service_prefix)
         @warning = opts.fetch(:warning, nil)

data/lib/riemann/tools/dir_space.rb

@@ -15,6 +15,8 @@ module Riemann
       opt :alert_on_missing, 'Send a critical metric if the directory is missing?', default: true
 
       def initialize
+        super
+
         @dir = opts.fetch(:directory)
         @service_prefix = opts.fetch(:service_prefix)
         @warning = opts.fetch(:warning, nil)

data/lib/riemann/tools/diskstats.rb

@@ -11,12 +11,14 @@ module Riemann
       opt :ignore_devices, 'Devices to ignore', type: :strings, default: nil
 
       def initialize
+        super
+
         @old_state = nil
       end
 
       def state
         f = File.read('/proc/diskstats')
-        state = f.split("\n").reject { |d| d =~ /(ram|loop)/ }.each_with_object({}) do |line, s|
+        state = f.split("\n").grep_v(/(ram|loop)/).each_with_object({}) do |line, s|
           next unless line =~ /^(?:\s+\d+){2}\s+([\w\d-]+) (.*)$/
 
           dev = Regexp.last_match(1)
@@ -43,13 +45,13 @@ module Riemann
         # Filter interfaces
         if (is = opts[:devices])
           state = state.select do |service, _value|
-            is.include? service.split(' ').first
+            is.include? service.split.first
           end
         end
 
         if (ign = opts[:ignore_devices])
           state = state.reject do |service, _value|
-            ign.include? service.split(' ').first
+            ign.include? service.split.first
           end
         end
 
@@ -80,7 +82,7 @@ module Riemann
             next unless service =~ /io time$/
 
             report(
-              service: "diskstats #{service.gsub(/time/, 'util')}",
+              service: "diskstats #{service.gsub('time', 'util')}",
               metric: (delta.to_f / (opts[:interval] * 1000)),
               state: 'ok',
             )

data/lib/riemann/tools/fd.rb

@@ -16,6 +16,8 @@ module Riemann
       opt :processes, 'list of processes to measure fd usage in addition to system total', type: :ints
 
       def initialize
+        super
+
         @limits = {
           fd: { critical: opts[:fd_sys_critical], warning: opts[:fd_sys_warning] },
           process: { critical: opts[:fd_proc_critical], warning: opts[:fd_proc_warning] },

data/lib/riemann/tools/freeswitch.rb

@@ -13,6 +13,8 @@ module Riemann
       opt :pid_file, 'FreeSWITCH daemon pidfile', type: String, default: '/var/run/freeswitch/freeswitch.pid'
 
       def initialize
+        super
+
         @limits = {
           calls: { critical: opts[:calls_critical], warning: opts[:calls_warning] },
         }

data/lib/riemann/tools/haproxy.rb

@@ -16,6 +16,8 @@ module Riemann
       opt :user_agent, 'User-Agent header for HTTP requests', short: :none, default: "#{File.basename($PROGRAM_NAME)}/#{Riemann::Tools::VERSION} (+https://github.com/riemann/riemann-tools)"
 
       def initialize
+        super
+
         @uri = URI("#{opts[:stats_url]};csv")
       end
 

data/lib/riemann/tools/health.rb

@@ -11,10 +11,15 @@ module Riemann
       include Riemann::Tools
       include Riemann::Tools::Utils
 
+      PROC_PID_INIT_INO = 0xEFFFFFFC
+      SI_UNITS = '_kMGTPEZYRQ'
+
       opt :cpu_warning, 'CPU warning threshold (fraction of total jiffies)', default: 0.9
       opt :cpu_critical, 'CPU critical threshold (fraction of total jiffies)', default: 0.95
       opt :disk_warning, 'Disk warning threshold (fraction of space used)', default: 0.9
       opt :disk_critical, 'Disk critical threshold (fraction of space used)', default: 0.95
+      opt :disk_warning_leniency, 'Disk warning threshold (amount of free space)', short: :none, default: '500G'
+      opt :disk_critical_leniency, 'Disk critical threshold (amount of free space)', short: :none, default: '250G'
       opt :disk_ignorefs, 'A list of filesystem types to ignore',
           default: %w[anon_inodefs autofs cd9660 devfs devtmpfs fdescfs iso9660 linprocfs linsysfs nfs overlay procfs squashfs tmpfs]
       opt :load_warning, 'Load warning threshold (load average / core)', default: 3.0
@@ -30,9 +35,11 @@ module Riemann
       opt :checks, 'A list of checks to run.', type: :strings, default: %w[cpu load memory disk swap]
 
       def initialize
+        super
+
         @limits = {
           cpu: { critical: opts[:cpu_critical], warning: opts[:cpu_warning] },
-          disk: { critical: opts[:disk_critical], warning: opts[:disk_warning] },
+          disk: { critical: opts[:disk_critical], warning: opts[:disk_warning], critical_leniency_kb: human_size_to_number(opts[:disk_critical_leniency]) / 1024, warning_leniency_kb: human_size_to_number(opts[:disk_warning_leniency]) / 1024 },
           load: { critical: opts[:load_critical], warning: opts[:load_warning] },
           memory: { critical: opts[:memory_critical], warning: opts[:memory_warning] },
           uptime: { critical: opts[:uptime_critical], warning: opts[:uptime_warning] },
@@ -154,6 +161,11 @@ module Riemann
         end
       end
 
+      def linux_running_in_container?
+        @linux_running_in_container = File.readlink('/proc/self/ns/pid') != "pid:[#{PROC_PID_INIT_INO}]" if @linux_running_in_container.nil?
+        @linux_running_in_container
+      end
+
       def linux_cpu
         new = File.read('/proc/stat')
         unless new[/cpu\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/]
@@ -188,19 +200,50 @@ module Riemann
       end
 
       def linux_memory
-        m = File.read('/proc/meminfo').split(/\n/).each_with_object({}) do |line, info|
+        m = File.read('/proc/meminfo').split("\n").each_with_object({}) do |line, info|
           x = line.split(/:?\s+/)
           # Assume kB...
           info[x[0]] = x[1].to_i
         end
 
-        free = m['MemFree'].to_i + m['Buffers'].to_i + m['Cached'].to_i
-        total = m['MemTotal'].to_i
+        free = m['MemFree'] + m['Buffers'] + m['Cached'] + linux_zfs_arc_evictable_memory
+        total = m['MemTotal']
         fraction = 1 - (free.to_f / total)
 
         report_pct :memory, fraction, "used\n\n#{reverse_numeric_sort_with_header(`ps -eo pmem,pid,comm`)}"
       end
 
+      # On Linux, the ZFS ARC is reported as used, not as cached memory.
+      # https://github.com/openzfs/zfs/issues/10251
+      #
+      # Gather ZFS ARC statisticts about evictable memory.  The available
+      # fields are listed here:
+      # https://github.com/openzfs/zfs/blob/master/include/sys/arc_impl.h
+      def linux_zfs_arc_evictable_memory
+        # When the system is a container, it can access the hosts stats that
+        # cause invalid memory usage reporting.  We should only remove
+        # evictable memory from the ZFS ARC on the host system.
+        return 0 if linux_running_in_container?
+
+        m = File.readlines('/proc/spl/kstat/zfs/arcstats').each_with_object(Hash.new(0)) do |line, info|
+          x = line.split(/\s+/)
+          info[x[0]] = x[2].to_i
+        end
+
+        (
+          m['anon_evictable_data'] +
+          m['anon_evictable_metadata'] +
+          m['mru_evictable_data'] +
+          m['mru_evictable_metadata'] +
+          m['mfu_evictable_data'] +
+          m['mfu_evictable_metadata'] +
+          m['uncached_evictable_data'] +
+          m['uncached_evictable_metadata']
+        ) / 1024 # We want kB...
+      rescue Errno::ENOENT
+        0
+      end
+
       def freebsd_cpu
         u2, n2, s2, t2, i2 = `sysctl -n kern.cp_time 2>/dev/null`.split.map(&:to_i) # FreeBSD has 5 cpu stats
 
@@ -374,14 +417,14 @@ module Riemann
       def df
         case @ostype
         when 'darwin', 'freebsd', 'openbsd'
-          `df -P -t no#{opts[:disk_ignorefs].join(',')}`
+          `df -Pk -t no#{opts[:disk_ignorefs].join(',')}`
         when 'sunos'
-          `df -P` # Is there a good way to exlude iso9660 here?
+          `df -Pk` # Is there a good way to exlude iso9660 here?
         else
           if @supports_exclude_type
-            `df -P #{opts[:disk_ignorefs].map { |fstype| "--exclude-type=#{fstype}" }.join(' ')}`
+            `df -Pk #{opts[:disk_ignorefs].map { |fstype| "--exclude-type=#{fstype}" }.join(' ')}`
           else
-            `df -P`
+            `df -Pk`
           end
         end
       end
@@ -397,12 +440,12 @@ module Riemann
 
           x = used.to_f / total_without_reservation
 
-          if x > @limits[:disk][:critical]
+          if x > @limits[:disk][:critical] && available < @limits[:disk][:critical_leniency_kb]
             alert "disk #{f[5]}", :critical, x, "#{f[4]} used"
-          elsif x > @limits[:disk][:warning]
+          elsif x > @limits[:disk][:warning] && available < @limits[:disk][:warning_leniency_kb]
             alert "disk #{f[5]}", :warning, x, "#{f[4]} used"
           else
-            alert "disk #{f[5]}", :ok, x, "#{f[4]} used"
+            alert "disk #{f[5]}", :ok, x, "#{f[4]} used, #{number_to_human_size(available * 1024, :floor)} free"
           end
         end
       end
@@ -468,6 +511,31 @@ module Riemann
         ].compact.join(' ')
       end
 
+      def human_size_to_number(value)
+        case value
+        when /^\d+$/ then value.to_i
+        when /^\d+k$/i then value.to_i * 1024
+        when /^\d+M$/i then value.to_i * (1024**2)
+        when /^\d+G$/i then value.to_i * (1024**3)
+        when /^\d+T$/i then value.to_i * (1024**4)
+        when /^\d+P$/i then value.to_i * (1024**5)
+        when /^\d+E$/i then value.to_i * (1024**6)
+        when /^\d+Z$/i then value.to_i * (1024**7)
+        when /^\d+Y$/i then value.to_i * (1024**8)
+        when /^\d+R$/i then value.to_i * (1024**9)
+        when /^\d+Q$/i then value.to_i * (1024**10)
+        else
+          raise %(Malformed size "#{value}", syntax is [0-9]+[#{SI_UNITS[1..]}]?)
+        end
+      end
+
+      def number_to_human_size(value, rounding = :round)
+        return value.to_s if value < 1024
+
+        r = Math.log(value, 1024).floor
+        format('%<size>.1f%<unit>ciB', size: (value.to_f / (1024**r)).send(rounding, 1), unit: SI_UNITS[r])
+      end
+
       def tick
         invalidate_cache
 

data/lib/riemann/tools/http_check.rb

@@ -32,15 +32,24 @@ module Riemann
       opt :resolvers, 'Run this number of resolver threads', short: :none, type: :integer, default: 5
       opt :workers, 'Run this number of worker threads', short: :none, type: :integer, default: 20
       opt :user_agent, 'User-Agent header for HTTP requests', short: :none, default: "#{File.basename($PROGRAM_NAME)}/#{Riemann::Tools::VERSION} (+https://github.com/riemann/riemann-tools)"
+      opt :ignored_asn, 'Ignore addresses belonging to these ASN', short: :none, type: :integers, default: []
+      opt :geoip_asn_database, 'Path to the GeoIP ASN database', short: :none, default: '/usr/share/GeoIP/GeoLite2-ASN.mmdb'
 
       def initialize
+        super
+
         @resolve_queue = Queue.new
         @work_queue = Queue.new
 
+        @resolvers = []
+        @workers = []
+
         opts[:resolvers].times do
-          Thread.new do
+          @resolvers << Thread.new do
             loop do
               uri = @resolve_queue.pop
+              Thread.exit unless uri
+
               host = uri.host
 
               addresses = Resolv::DNS.new.getaddresses(host)
@@ -53,21 +62,61 @@ module Riemann
                 end
               end
 
+              if opts[:ignored_asn].any?
+                addresses.reject! do |address|
+                  address_belongs_to_ignored_asn?(address)
+                end
+              end
+
+              next if addresses.empty?
+
               @work_queue.push([uri, addresses])
             end
           end
         end
 
         opts[:workers].times do
-          Thread.new do
+          @workers << Thread.new do
             loop do
               uri, addresses = @work_queue.pop
+              Thread.exit unless uri
+
               test_uri_addresses(uri, addresses)
             end
           end
         end
+      end
 
-        super
+      def address_belongs_to_ignored_asn?(address)
+        begin
+          require 'maxmind/geoip2'
+        rescue LoadError
+          raise StandardError, 'MaxMind::GeoIP2 is not available. Please install the maxmind-geoip2 gem for filtering by ASN.'
+        end
+
+        @reader ||= MaxMind::GeoIP2::Reader.new(database: opts[:geoip_asn_database])
+        asn = @reader.asn(address.to_s)
+
+        opts[:ignored_asn].include?(asn&.autonomous_system_number)
+      rescue MaxMind::GeoIP2::AddressNotFoundError
+        false
+      end
+
+      # Under normal operation, we have a single instance of this class for the
+      # lifetime of the process.  But when testing, we create a new instance
+      # for each test, each with its resolvers and worker threads.  The test
+      # process may end-up with a lot of running threads, hitting the OS limit
+      # of max threads by process and being unable to create more thread:
+      #
+      # ThreadError: can't create Thread: Resource temporarily unavailable
+      #
+      # To avoid this situation, we provide this method.
+      def shutdown
+        @resolve_queue.close
+        @resolvers.map(&:join)
+
+        @work_queue.close
+        @workers.map(&:join)
       end
 
       def tick
@@ -104,10 +153,8 @@ module Riemann
       def test_uri_addresses(uri, addresses)
         request = get_request(uri)
 
-        responses = []
-
-        addresses.each do |address|
-          responses << test_uri_address(uri, address.to_s, request)
+        responses = addresses.map do |address|
+          test_uri_address(uri, address.to_s, request)
         end
 
         responses.compact!
@@ -265,8 +312,8 @@ module Riemann
       end
 
       def latency_state(name, latency)
-        critical_threshold = opts["#{name}_latency_critical".to_sym]
-        warning_threshold = opts["#{name}_latency_warning".to_sym]
+        critical_threshold = opts[:"#{name}_latency_critical"]
+        warning_threshold = opts[:"#{name}_latency_warning"]
 
         return if critical_threshold.zero? || warning_threshold.zero?
 
@@ -301,14 +348,6 @@ module Riemann
         reported_uri.password = '**redacted**' if reported_uri.password
         reported_uri
       end
-
-      def endpoint_name(address, port)
-        if address.ipv6?
-          "[#{address}]:#{port}"
-        else
-          "#{address}:#{port}"
-        end
-      end
     end
   end
 end