fluent-plugin-node-exporter-metrics 0.1.0

data/lib/fluent/plugin/node_exporter/diskstats_collector.rb

@@ -0,0 +1,280 @@
+#
+# Copyright (C) 2021- Kentaro Hayashi
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "cmetrics"
+require "fluent/plugin/input"
+require "fluent/plugin/node_exporter/collector"
+
+module Fluent
+  module Plugin
+    module NodeExporter
+      class DiskstatsMetricsCollector < MetricsCollector
+
+        IGNORED_DEVICES = /^(ram|loop|fd|(h|s|v|xv)d[a-z]|nvme\d+n\d+p)\d+$/
+        # https://www.kernel.org/doc/Documentation/ABI/testing/procfs-diskstats
+        # major number ... time spent flushing
+        DISKSTATS_KNOWN_FIELDS = 20
+        # assume sector size = 512
+        SECTOR_SIZE = 512
+
+        METRIC_NAMES = %w(
+                reads_completed_total
+                reads_merged_total
+                read_bytes_total
+                read_time_seconds_total
+                writes_completed_total
+                writes_merged_total
+                written_bytes_total
+                write_time_seconds_total
+                io_now
+                io_time_seconds_total
+                io_time_weighted_seconds_total
+                discards_completed_total
+                discards_merged_total
+                discarded_sectors_total
+                discard_time_seconds_total
+                flush_requests_total
+                flush_requests_time_seconds_total
+        )
+
+        DISCARD_METRIC_NAMES = %w(
+               discards_completed_total
+               discards_merged_total
+               discarded_sectors_total
+               discard_time_seconds_total
+        )
+
+        FLUSH_METRIC_NAMES = %w(
+               flush_requests_total
+               flush_requests_time_seconds_total
+        )
+
+        def initialize(config={})
+          super(config)
+
+          @reads_completed_total = CMetrics::Counter.new
+          @reads_completed_total.create("node", "disk", "reads_completed_total",
+                                        "The total number of reads completed successfully.",
+                                        ["device"])
+
+          @reads_merged_total = CMetrics::Counter.new
+          @reads_merged_total.create("node", "disk", "reads_merged_total",
+                                     "The total number of reads merged.",
+                                     ["device"])
+
+          @read_bytes_total = CMetrics::Counter.new
+          @read_bytes_total.create("node", "disk", "read_bytes_total",
+                                   "The total number of bytes read successfully.",
+                                   ["device"])
+
+          @read_time_seconds_total = CMetrics::Counter.new
+          @read_time_seconds_total.create("node", "disk", "reads_time_seconds_total",
+                                          "The total number of seconds spent by all reads.",
+                                          ["device"])
+
+          @writes_completed_total = CMetrics::Counter.new
+          @writes_completed_total.create("node", "disk", "writes_completed_total",
+                                      "The total number of writes completed successfully.",
+                                      ["device"])
+
+          @writes_merged_total = CMetrics::Counter.new
+          @writes_merged_total.create("node", "disk", "writes_merged_total",
+                                      "The number of writes merged.",
+                                      ["device"])
+
+          @written_bytes_total = CMetrics::Counter.new
+          @written_bytes_total.create("node", "disk", "written_bytes_total",
+                                      "The total number of bytes written successfully.",
+                                      ["device"])
+
+          @write_time_seconds_total = CMetrics::Counter.new
+          @write_time_seconds_total.create("node", "disk", "write_time_seconds_total",
+                                           "This is the total number of seconds spent by all writes.",
+                                           ["device"])
+
+          @io_now = CMetrics::Gauge.new
+          @io_now.create("node", "disk", "io_now",
+                         "The number of I/Os currently in progress.",
+                         ["device"])
+
+          @io_time_seconds_total = CMetrics::Counter.new
+          @io_time_seconds_total.create("node", "disk", "io_time_seconds_total",
+                                        "Total seconds spent doing I/Os.",
+                                        ["device"])
+
+          @io_time_weighted_seconds_total = CMetrics::Counter.new
+          @io_time_weighted_seconds_total.create("node", "disk", "io_time_weighted_seconds_total",
+                                                 "The number of I/Os currently in progress.",
+                                                 ["device"])
+
+          if kernel_version_over4_18?
+            # Kernel >= 4.18
+            @discards_completed_total = CMetrics::Counter.new
+            @discards_completed_total.create("node", "disk", "discards_completed_total",
+                                             "The total number of discards completed successfully.",
+                                             ["device"])
+
+            @discards_merged_total = CMetrics::Counter.new
+            @discards_merged_total.create("node", "disk", "discards_merged_total",
+                                          "The total number of discards merged.", ["device"])
+
+            @discarded_sectors_total = CMetrics::Counter.new
+            @discarded_sectors_total.create("node", "disk", "discards_sectors_total",
+                                            "The total number of sectors discarded successfully.",
+                                            ["device"])
+
+            @discard_time_seconds_total = CMetrics::Counter.new
+            @discard_time_seconds_total.create("node", "disk", "discard_time_seconds_total",
+                                               "The total number of seconds spent by all discards.",
+                                               ["device"])
+          end
+
+          if kernel_version_over5_5?
+            @flush_requests_total = CMetrics::Counter.new
+            @flush_requests_total.create("node", "disk", "flush_requests_total",
+                                         "The total number of flush requests completed successfully",
+                                         ["device"])
+
+            @flush_requests_time_seconds_total = CMetrics::Counter.new
+            @flush_requests_time_seconds_total.create("node", "disk", "flush_requests_time_seconds_total",
+                                                      "This is the total number of seconds spent by all flush requests.",
+                                                      ["device"])
+          end
+
+          @metrics = {}
+        end
+
+        def kernel_version_over4_18?
+          Gem::Version.new(Etc.uname[:release].split('-', 2).first) >= Gem::Version.new("4.18")
+        end
+
+        def kernel_version_over5_5?
+          Gem::Version.new(Etc.uname[:release].split('-', 2).first) >= Gem::Version.new("5.5.0")
+        end
+
+        def target_devices
+          devices = []
+          diskstats_path = File.join(@procfs_path, "diskstats")
+          File.readlines(diskstats_path).each do |line|
+            _, _, device, _ = line.split(' ', DISKSTATS_KNOWN_FIELDS)
+            unless IGNORED_DEVICES.match?(device)
+              devices << device
+            end
+          end
+          devices
+        end
+
+        def run
+          diskstats_update
+        end
+
+        def diskstats_update
+          diskstats_path = File.join(@procfs_path, "diskstats")
+          File.readlines(diskstats_path).each do |line|
+            _, _, device,
+            reads_completed_value, reads_merged_value, read_bytes_value, read_time_seconds_value,
+            writes_completed_value, writes_merged_value, written_bytes_value, write_time_seconds_value,
+            io_now_value, io_time_seconds_value, io_time_weighted_seconds_value,
+            discards_completed_value, discards_merged_value, discarded_sectors_value, discard_time_seconds_value,
+            flush_requests_value, flush_requests_time_seconds_value = line.split(' ', DISKSTATS_KNOWN_FIELDS)
+            unless IGNORED_DEVICES.match?(device)
+              METRIC_NAMES.each do |field|
+                case field
+                when "reads_completed_total"
+                  @reads_completed_total.set(reads_completed_value.to_f, [device])
+                when "reads_merged_total"
+                  @reads_merged_total.set(reads_merged_value.to_f, [device])
+                when "read_bytes_total"
+                  @read_bytes_total.set(read_bytes_value.to_f * SECTOR_SIZE, [device])
+                when "read_time_seconds_total"
+                  @read_time_seconds_total.set(read_time_seconds_value.to_f * 0.001, [device])
+                when "writes_completed_total"
+                  @writes_completed_total.set(writes_completed_value.to_f, [device])
+                when "writes_merged_total"
+                  @writes_merged_total.set(writes_merged_value.to_f, [device])
+                when "written_bytes_total"
+                  @written_bytes_total.set(written_bytes_value.to_f * SECTOR_SIZE, [device])
+                when "write_time_seconds_total"
+                  @write_time_seconds_total.set(write_time_seconds_value.to_f * 0.001, [device])
+                when "io_now"
+                  @io_now.set(io_now_value.to_f, [device])
+                when "io_time_seconds_total"
+                  @io_time_seconds_total.set(io_time_seconds_value.to_f * 0.001, [device])
+                when "io_time_weighted_seconds_total"
+                  @io_time_weighted_seconds_total.set(io_time_weighted_seconds_value.to_f * 0.001, [device])
+                when "discards_completed_total"
+                  if kernel_version_over4_18?
+                    @discards_completed_total.set(discards_completed_value.to_f, [device])
+                  end
+                when "discards_merged_total"
+                  if kernel_version_over4_18?
+                    @discards_merged_total.set(discards_merged_value.to_f, [device])
+                  end
+                when "discarded_sectors_total"
+                  if kernel_version_over4_18?
+                    @discarded_sectors_total.set(discarded_sectors_value.to_f, [device])
+                  end
+                when "discard_time_seconds_total"
+                  if kernel_version_over4_18?
+                    @discard_time_seconds_total.set(discard_time_seconds_value.to_f * 0.001, [device])
+                  end
+                when "flush_requests_total"
+                  if kernel_version_over5_5?
+                    @flush_requests_total.set(flush_requests_value.to_f, [device])
+                  end
+                when "flush_requests_time_seconds_total"
+                  if kernel_version_over5_5?
+                    @flush_requests_time_seconds_total.set(flush_requests_time_seconds_value.to_f * 0.001, [device])
+                  end
+                end
+              end
+              @metrics = {
+                reads_completed_total: @reads_completed_total,
+                reads_merged_total: @reads_merged_total,
+                read_bytes_total: @read_bytes_total,
+                read_time_seconds_total: @read_time_seconds_total,
+                writes_completed_total: @writes_completed_total,
+                writes_merged_total: @writes_merged_total,
+                written_bytes_total: @written_bytes_total,
+                write_time_seconds_total: @write_time_seconds_total,
+                io_now: @io_now,
+                io_time_seconds_total: @io_time_seconds_total,
+                io_time_weighted_seconds_total: @io_time_weighted_seconds_total
+              }
+              if kernel_version_over4_18?
+                @metrics.merge!({
+                                  discards_completed_total: @discards_completed_total,
+                                  discards_merged_total: @discards_merged_total,
+                                  discarded_sectors_total: @discarded_sectors_total,
+                                  discard_time_seconds_total: @discard_time_seconds_total
+                               })
+              end
+              if kernel_version_over5_5?
+                @metrics.merge!({
+                                  flush_requests_total: @flush_requests_total,
+                                  flush_requests_time_seconds_total: @flush_requests_time_seconds_total
+                                })
+              end
+            end
+          end
+        end
+
+        def cmetrics
+          @metrics
+        end
+      end
+    end
+  end
+end

data/lib/fluent/plugin/node_exporter/filefd_collector.rb

@@ -0,0 +1,60 @@
+#
+# Copyright 2021- Kentaro Hayashi
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "cmetrics"
+require "fluent/plugin/input"
+require "fluent/plugin/node_exporter/collector"
+
+module Fluent
+  module Plugin
+    module NodeExporter
+      class FilefdMetricsCollector < MetricsCollector
+        def initialize(config={})
+          super(config)
+
+          @allocated = CMetrics::Gauge.new
+          @allocated.create("node", "filefd", "allocated", "File descriptor statistics: allocated.")
+
+          @maximum = CMetrics::Gauge.new
+          @maximum.create("node", "filefd", "maximum", "File descriptor statistics: maximum.")
+        end
+
+        def run
+          filefd_update
+        end
+
+        def filefd_update
+          # Etc.uname returns at least sysname,release,version,machine,nodename
+          # but it is not guaranteed to return domainname.
+          file_nr_path = File.join(@procfs_path, "/sys/fs/file-nr")
+          entry = File.read(file_nr_path).split
+          unless entry.size == 3
+            $log.warn("invalid number of field <#{file_nr_path}>: #{entry.size}")
+            return
+          end
+          @allocated.set(entry.first.to_f)
+          @maximum.set(entry.last.to_f)
+        end
+
+        def cmetrics
+          {
+            filefd_allocated: @allocated,
+            filefd_maximum: @maximum
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fluent/plugin/node_exporter/loadavg_collector.rb

@@ -0,0 +1,64 @@
+#
+# Copyright 2021- Kentaro Hayashi
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "cmetrics"
+require "fluent/plugin/input"
+require "fluent/plugin/node_exporter/collector"
+
+module Fluent
+  module Plugin
+    module NodeExporter
+      class LoadavgMetricsCollector < MetricsCollector
+        def initialize(config={})
+          super(config)
+
+          @load1 = CMetrics::Gauge.new
+          @load1.create("node", "", "load1", "1m load average.")
+
+          @load5 = CMetrics::Gauge.new
+          @load5.create("node", "", "load5", "5m load average.")
+
+          @load15 = CMetrics::Gauge.new
+          @load15.create("node", "", "load15", "15m load average.")
+        end
+
+        def run
+          loadavg_update
+        end
+
+        def loadavg_update
+          loadavg_path = File.join(@procfs_path, "/loadavg")
+          # Use 1 explicitly for default gauge value
+          fields = File.read(loadavg_path).split
+          unless fields.size == 5
+            $log.warn("invalid number of fields <#{loadavg_path}>: <#{fields.size}>")
+            return
+          end
+          @load1.set(fields[0].to_f)
+          @load5.set(fields[1].to_f)
+          @load15.set(fields[2].to_f)
+        end
+
+        def cmetrics
+          {
+            loadavg1: @load1,
+            loadavg5: @load5,
+            loadavg15: @load15
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fluent/plugin/node_exporter/meminfo_collector.rb

@@ -0,0 +1,61 @@
+#
+# Copyright 2021- Kentaro Hayashi
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "cmetrics"
+require "fluent/plugin/input"
+require "fluent/plugin/node_exporter/collector"
+
+module Fluent
+  module Plugin
+    module NodeExporter
+      class MeminfoMetricsCollector < MetricsCollector
+
+        def initialize(config={})
+          super(config)
+
+          @metrics = {}
+        end
+
+        def run
+          meminfo_update
+        end
+
+        def meminfo_update
+          meminfo_path = File.join(@procfs_path, "meminfo")
+          File.readlines(meminfo_path).each do |line|
+            name, value, unit = line.split
+            name.delete!(":")
+            if name.end_with?("(anon)") or name.end_with?("(file)")
+              name.sub!(/\((anon)\)|\((file)\)/, "_\\1\\2")
+            end
+            if unit
+              name << "_bytes"
+              value = value.to_f * 1024
+            end
+            metric_name = "node_memory_#{name}"
+            @gauge = CMetrics::Gauge.new
+            @gauge.create("node", "memory", name, "#{name}.")
+            @gauge.set(value.to_f)
+            @metrics[metric_name.intern] = @gauge
+          end
+        end
+
+        def cmetrics
+          @metrics
+        end
+      end
+    end
+  end
+end

data/lib/fluent/plugin/node_exporter/netdev_collector.rb

@@ -0,0 +1,92 @@
+#
+# Copyright 2021- Kentaro Hayashi
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "cmetrics"
+require "fluent/plugin/input"
+require "fluent/plugin/node_exporter/collector"
+
+module Fluent
+  module Plugin
+    module NodeExporter
+      class NetdevMetricsCollector < MetricsCollector
+
+        def initialize(config={})
+          super(config)
+
+          @metrics = {}
+        end
+
+        def run
+          netdev_update
+        end
+
+        RECEIVE_FIELDS = %w(bytes packets errs drop fifo frame compressed multicast)
+        TRANSMIT_FIELDS = %w(bytes packets errs drop fifo colls carrier compressed)
+
+        def target_devices
+          devices = []
+          netdev_path = File.join(@procfs_path, "net/dev")
+          File.readlines(netdev_path).each_with_index do |line, index|
+            next if index < 2
+            interface, _ = line.split
+            interface.delete!(":")
+            devices << interface
+          end
+          devices
+        end
+
+        def netdev_update
+          netdev_path = File.join(@procfs_path, "net/dev")
+          RECEIVE_FIELDS.each_with_index do |field, index|
+            metric_name = "receive_#{field}_total"
+            @counter = CMetrics::Counter.new
+            @counter.create("node", "network", metric_name, "Network device statistic #{metric_name}.", ["device"])
+            @metrics[metric_name.intern] = @counter
+          end
+          TRANSMIT_FIELDS.each_with_index do |field, index|
+            metric_name = "transmit_#{field}_total"
+            @counter = CMetrics::Counter.new
+            @counter.create("node", "network", metric_name, "Network device statistic #{metric_name}.", ["device"])
+            @metrics[metric_name.intern] = @counter
+          end
+          File.readlines(netdev_path).each_with_index do |line, index|
+            # net/dev must be 3 columns
+            if index == 0 and line.split("|").size != 3
+              break
+            end
+            # first 2 line are header (Inter-face/Receive/Transmit)
+            next if index < 2
+
+            interface, *values = line.split
+            interface.delete!(":")
+
+            RECEIVE_FIELDS.each_with_index do |field, index|
+              metric_name = "receive_#{field}_total"
+              @metrics[metric_name.intern].set(values[index].to_f, [interface])
+            end
+            TRANSMIT_FIELDS.each_with_index do |field, index|
+              metric_name = "transmit_#{field}_total"
+              @metrics[metric_name.intern].set(values[index + RECEIVE_FIELDS.size].to_f, [interface])
+            end
+          end
+        end
+
+        def cmetrics
+          @metrics
+        end
+      end
+    end
+  end
+end

data/lib/fluent/plugin/node_exporter/stat_collector.rb

@@ -0,0 +1,84 @@
+#
+# Copyright 2021- Kentaro Hayashi
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "cmetrics"
+require "fluent/plugin/input"
+require "fluent/plugin/node_exporter/collector"
+
+module Fluent
+  module Plugin
+    module NodeExporter
+      class StatMetricsCollector < MetricsCollector
+        def initialize(config={})
+          super(config)
+
+          @intr_total = CMetrics::Counter.new
+          @intr_total.create("node", "", "intr_total", "Total number of interrupts serviced.")
+
+          @context_switches_total = CMetrics::Counter.new
+          @context_switches_total.create("node", "", "context_switches_total", "Total number of context switches.")
+
+          @forks_total = CMetrics::Counter.new
+          @forks_total.create("node", "", "forks_total", "Total number of forks.")
+
+          @boot_time_seconds = CMetrics::Gauge.new
+          @boot_time_seconds.create("node", "", "boot_time_seconds", "Node boot time, in unixtime.")
+
+          @procs_running = CMetrics::Gauge.new
+          @procs_running.create("node", "", "procs_running", "Number of processes in runnable state.")
+
+          @procs_blocked = CMetrics::Gauge.new
+          @procs_blocked.create("node", "", "procs_blocked", "Number of processes blocked waiting for I/O to complete.")
+        end
+
+        def run
+          stat_update
+        end
+
+        def stat_update
+          stat_path = File.join(@procfs_path, "stat")
+          File.readlines(stat_path).each do |line|
+            entry, value, _ = line.split
+            case entry
+            when "intr"
+              @intr_total.set(value.to_f)
+            when "ctxt"
+              @context_switches_total.set(value.to_f)
+            when "btime"
+              @boot_time_seconds.set(value.to_f)
+            when "processes"
+              @forks_total.set(value.to_f)
+            when "procs_running"
+              @procs_running.set(value.to_f)
+            when "procs_blocked"
+              @procs_blocked.set(value.to_f)
+            end
+          end
+        end
+
+        def cmetrics
+          {
+            intr_total: @intr_total,
+            context_switches_total: @context_switches_total,
+            forks_total: @forks_total,
+            boot_time_seconds: @boot_time_seconds,
+            procs_running: @procs_running,
+            procs_blocked: @procs_blocked
+          }
+        end
+      end
+    end
+  end
+end