instrumental_tools 0.6.0 → 1.0.0.pre.1

data/examples/README.md

@@ -0,0 +1,7 @@
+# Custom Script Examples
+
+The following scripts are examples of how to monitor other parts of your system not natively supported by `instrument_server`.
+
+* [MySQL](mysql/README.md)
+* [Docker](docker/README.md)
+* [Mongo](mongo/README.md)

data/examples/docker/README.md

@@ -0,0 +1,20 @@
+# Docker Metrics
+
+This script will generate performance metrics for each running Docker container based on the name of that container. It will also output information regarding the number of running docker containers for that host.
+
+Each Docker container will have the following metrics output:
+
+* `CONTAINER_NAME.system_total` - Total system CPU time spent for container
+* `CONTAINER_NAME.user_total` - Total user CPU time spent for container
+* `CONTAINER_NAME.system` - Current percent usage of system time spent for container
+* `CONTAINER_NAME.user` - Current percent usage of user time spent for container
+* `CONTAINER_NAME.cache_mb` - Current cache memory allocated for container
+* `CONTAINER_NAME.rss_mb` - Current resident memory allocated for container
+* `CONTAINER_NAME.mapped_file_mb` - Current mapped memory allocated for container
+* `CONTAINER_NAME.swap_mb` - Current swap memory allocated for container
+
+The following metric will be output only once for the host:
+
+* `running` - The total number of docker containers running on the host
+
+This script will only work if the `docker ps` process is exeutable by the same user that is running `instrument_server`. You should ensure that the user that exeutes the `instrument_server` process belongs to the `docker` group on your system.

data/examples/docker/docker.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+stdout_r, stdout_w = IO.pipe
+pid                = Process.spawn("docker", "ps", :err => STDERR, :out => stdout_w)
+_, exit_status     = Process.wait2(pid)
+
+stdout_w.close
+
+output = stdout_r.read.chomp
+
+stdout_r.close
+
+if !exit_status.success?
+  STDERR.puts output
+  exit 1
+end
+
+header, *content = output.lines.map(&:chomp)
+
+header            = header.split(/\s{2,}/)
+content           = content.map { |line| line.split(/\s{2,}/) }
+docker_containers = content.map { |data| Hash[header.zip(data)] }
+cpu_info          = "/sys/fs/cgroup/cpuacct/"
+mem_info          = "/sys/fs/cgroup/memory/"
+
+previous_run_time = ARGV[0].to_i
+current_time      = Time.now.to_i
+run_interval      = (current_time - previous_run_time).to_f
+previously_ran    = previous_run_time > 0
+previous_values   = {}
+
+if previously_ran
+  previous_output = STDIN.read.chomp.lines
+                                    .map { |line| line.chomp.split }
+                                    .map { |(name, value, _)| [name, value.to_f] }
+  previous_values = Hash[previous_output]
+end
+
+all_stats = docker_containers.map do |container|
+  stats = {}
+  container_name = Array(container["NAMES"].to_s.split(",")).first || container["CONTAINER ID"][0..7]
+  Dir[File.join(cpu_info, "**", container["CONTAINER ID"] + "*", "cpuacct.stat")].each do |file|
+
+    cpu_stats = Hash[File.read(file).lines.map { |line| line.chomp.split }]
+
+    %w{system user}.each do |stat|
+      output_stat = [container_name, stat + "_total"].join(".")
+      stats[output_stat] = cpu_stats[stat]
+      if previously_ran
+        time_over_interval                      = (cpu_stats[stat].to_f - previous_values[output_stat]) / run_interval
+        stats[[container_name, stat].join(".")] = time_over_interval
+      end
+    end
+  end
+  Dir[File.join(mem_info, "**", container["CONTAINER ID"] + "*", "memory.stat")].each do |file|
+    mem_stats = Hash[File.read(file).lines.map { |line| line.chomp.split }]
+
+    %w{cache rss mapped_file swap}.each do |stat|
+      stats[[container_name, stat + "_mb"].join(".")] = mem_stats[stat].to_i / 1024.0 / 1024.0
+    end
+  end
+  stats
+end
+
+puts "running %s" % docker_containers.size
+all_stats.each do |row|
+  row.each do |metric, value|
+    puts [metric, value].join(" ")
+  end
+end
+
+if !previously_ran
+  exit 1
+end

data/examples/mongo/README.md

@@ -0,0 +1,25 @@
+# Mongo Metrics
+
+The [`mongo_3.rb`](mongo_3.rb) script generates metrics from the `mongotop` and `mongostat` commands for a Mongo 3.0 database. The following metrics will be output for every collection in your system:
+
+* `mongotop.COLLECTION.total_ms` - Total ms spent in collection
+* `mongotop.COLLECTION.write_ms` - Write ms spent in collection
+* `mongotop.COLLECTION.read_ms` - Read ms spent in collection
+
+Additionally, the following database level metrics will be output:
+
+* `mongostat.HOST.conn` - Current number of connections
+* `mongostat.HOST.delete`- Delete commands issued
+* `mongostat.HOST.faults` - Page faults occurred
+* `mongostat.HOST.flushes` - Flushes performed
+* `mongostat.HOST.getmore` - Get More commands issued
+* `mongostat.HOST.idx_miss_pct` - Percentage of queries missing an index
+* `mongostat.HOST.insert` - Insert commands issued
+* `mongostat.HOST.mapped_mb` - Database files mapped into memory
+* `mongostat.HOST.netIn_mb` -  Amount of network I/O received
+* `mongostat.HOST.netOut_mb` - Amount of network I/O sent
+* `mongostat.HOST.query` - Number of queries received
+* `mongostat.HOST.res_mb` - Resident memory of db process
+* `mongostat.HOST.update` - Number of update commands issued
+
+These metrics can only be gathered using the 3.0 version of the Mongo command line tools.

data/examples/mongo/mongo_3.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+
+# Requires Mongo 3.0 command line tools
+# ( uses --json for output, not available prior to 3.0 )
+
+MONGO_HOST           = ENV["MONGO_HOST"] || "127.0.0.1"
+MONGO_PORT           = ENV["MONGO_PORT"] || 27017
+MONGO_USER           = ENV["MONGO_USER"]
+MONGO_PWD            = ENV["MONGO_PASSWORD"]
+MONGO_AUTH_MECHANISM = ENV["MONGO_AUTH_MECHANISM"]
+MONGO_AUTH_DB        = ENV["MONGO_AUTH_DB"]
+
+CMDS                 = %w{mongotop mongostat}
+
+outputs = CMDS.map do |cmd|
+  cmd_with_arguments = [cmd, "--json", "-n", "1", "--host", MONGO_HOST, "--port", MONGO_PORT]
+  if MONGO_USER
+    cmd_with_arguments += ["--user", MONGO_USER]
+  end
+  if MONGO_PWD
+    cmd_with_arguments += ["--password", MONGO_PWD]
+  end
+  if MONGO_AUTH_DB
+    cmd_with_arguments += ["--authenticationDatabase", MONGO_AUTH_DB]
+  end
+  if MONGO_AUTH_MECHANISM
+    cmd_with_arguments += ["--authenticationMechanism", MONGO_AUTH_MECHANISM]
+  end
+  stdout_r, stdout_w = IO.pipe
+  pid                = Process.spawn(*cmd_with_arguments.map(&:to_s), :err => STDERR, :out => stdout_w)
+  _, exit_status     = Process.wait2(pid)
+  stdout_w.close
+  output             = stdout_r.read.chomp
+  stdout_r.close
+  if !exit_status.success?
+    STDERR.puts output
+    exit 1
+  end
+  [cmd, output]
+end
+
+cmd_to_output = Hash[outputs]
+
+if (output = cmd_to_output["mongotop"])
+  stats = YAML.load(output)
+  (stats["totals"] || {}).each do |collection, totals|
+    stat = "mongotop.%s" % collection.gsub(/[^a-z0-9\-\_]/i, "_")
+    %w{total read write}.each do |metric|
+      puts "%s.%s_ms %s" % [stat, metric, totals[metric]["time"]]
+    end
+  end
+end
+
+if (output = cmd_to_output["mongostat"])
+  stats = YAML.load(output)
+  stats.each do |host, metrics|
+    stat = "mongostat.%s" % host.gsub(/[^a-z0-9\-\_]/i, "_")
+    ["conn", "delete", "faults", "flushes", "getmore", ["idx miss %", "idx_miss_pct"], "insert", "mapped", "netIn", "netOut", "query", "res", "update"].each do |metric|
+      name, value = case metric
+                    when Array
+                      key, output_key = metric
+                      [output_key, metrics[key]]
+                    else
+                      [metric, metrics[metric]]
+                    end
+      if value =~ /\A([\d\.]+)(b|k|M|G)\Z/
+        value = case $2
+                when "b"
+                  $1.to_f / 1024.0 / 1024.0
+                when "k"
+                  $1.to_f / 1024.0
+                when "M"
+                  $1.to_f
+                when "G"
+                  $1.to_f * 1024.0
+                end
+        name += "_mb"
+      end
+      value     = value.to_s.gsub(/[^\d\.]/, "")
+      puts "%s.%s %s" % [stat, name, value]
+    end
+  end
+end

data/examples/mysql/README.md

@@ -0,0 +1,13 @@
+# MySQL Metrics
+
+The MySQL metrics script collects the following metrics:
+
+* Queries - `Queries`
+* Bytes Sent  - `Bytes_sent`
+* Bytes Received - `Bytes_received`
+* Connections - `Connections`
+* Slow queries - `Slow_queries`
+
+Additionally, it estimates the number received per second ( `Queries_per_second`, etc. ).
+
+You may either edit the values `MYSQL_HOST`, `MYSQL_PORT`, `MYSQL_USER`, `MYSQL_DEFAULTS_FILE` / `MYSQL_PASSWORD` in the [`mysql_status.rb`](mysql_status.rb) to reflect your server's information or provide them as environment variables to the `instrument_server` process. It is advisable that you use a MySQL CNF file to specify password information if your server uses password authentication. See [the MySQL page regarding password security](http://dev.mysql.com/doc/refman/5.0/en/password-security-user.html) for more information.

data/examples/mysql/mysql_status.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+# Ensure your instrument_server process runs with these environment variables set,
+# or replace with your own.
+
+MYSQL_HOST              = ENV["MYSQL_HOST"] || "localhost"
+MYSQL_PORT              = ENV["MYSQL_PORT"] || 3306
+MYSQL_USER              = ENV["MYSQL_USER"]
+MYSQL_DEFAULTS_FILE     = ENV["MYSQL_DEFAULTS_FILE"]
+MYSQL_PASSWORD          = ENV["MYSQL_PASSWORD"]
+
+RATE_METRICS_TO_INSPECT = %w{Queries Bytes_sent Bytes_received Connections Slow_queries}
+CANARY_METRIC           = "Queries"
+
+env  = {}
+args = []
+if MYSQL_DEFAULTS_FILE.to_s.size > 0
+  args << "--defaults-file=%s" % MYSQL_DEFAULTS_FILE
+else
+  env = { "MYSQL_PWD" => MYSQL_PASSWORD }
+end
+args += [
+          "-N",
+          "-B",
+          "-e",
+          "SHOW GLOBAL STATUS"
+        ]
+if MYSQL_USER
+  args += ["--user", MYSQL_USER]
+end
+if MYSQL_HOST
+  args += ["--host", MYSQL_HOST]
+end
+if MYSQL_PORT
+  args += ["--port", MYSQL_PORT]
+end
+
+stdout_r, stdout_w = IO.pipe
+
+pid = Process.spawn(env, "mysql", *args.map(&:to_s), :out => stdout_w, :err => STDERR)
+
+pid, exit_status = Process.wait2(pid)
+
+stdout_w.close
+
+previous_run_time = ARGV[0].to_i
+current_time      = Time.now.to_i
+run_interval      = (current_time - previous_run_time).to_f
+previously_ran    = previous_run_time > 0
+previous_values   = {}
+
+if previously_ran
+  previous_output = STDIN.read.chomp.each_line.map
+                                    .map { |line| line.split }
+                                    .map { |(name, value, _)| [name, value.to_f] }
+  previous_values = Hash[previous_output]
+end
+
+if !exit_status.success?
+  exit exit_status.to_i
+else
+  output = stdout_r.read.lines                                         # each line
+                        .map { |line| line.chomp.split }              # split by space characters
+                        .map { |(name, value, _)| [name, value.to_f] } # with values coerced to floats
+  stats  = Hash[output]
+  if (stats[CANARY_METRIC] < previous_values[CANARY_METRIC].to_i) || previous_values[CANARY_METRIC].nil?
+    # The server has restarted, don't trust previous values for calculating difference
+    previously_ran = false
+  end
+  if previously_ran
+    RATE_METRICS_TO_INSPECT.each do |metric|
+      stats["%s_per_second" % metric] = (stats[metric] - previous_values[metric]) / run_interval
+    end
+  end
+  RATE_METRICS_TO_INSPECT.each do |metric|
+    puts [metric, stats[metric]].join(" ")
+    per_second_metric = "%s_per_second" % metric
+    per_second        = stats[per_second_metric]
+    if per_second
+      puts [per_second_metric, per_second].join(" ")
+    end
+  end
+  if previously_ran
+    exit 0
+  else
+    exit 1
+  end
+end

data/instrumental_tools.gemspec

@@ -14,7 +14,9 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
-  s.add_runtime_dependency(%q<json>, [">=0"])
+
+  s.required_ruby_version = '>= 1.9'
+
   s.add_runtime_dependency(%q<instrumental_agent>, [">=0.12.6"])
   s.add_runtime_dependency(%q<pidly>, [">=0.1.3"])
   s.add_development_dependency(%q<rake>, [">=0"])

data/lib/instrumental_tools/metric_script_executor.rb

@@ -0,0 +1,96 @@
+require 'benchmark'
+
+class MetricScriptExecutor
+
+  attr_reader :directory, :previous, :last_ran_at
+
+  def initialize(directory)
+    @directory   = directory
+    @previous    = {}
+  end
+
+  def can_execute_file?(path)
+    stat = File::Stat.new(path)
+    stat.executable? && file_is_owner_only?(stat)
+  end
+
+  def can_execute_in_directory?(directory)
+    stat = File::Stat.new(directory)
+    stat.directory? && file_is_owner_only?(stat)
+  end
+
+  def file_is_owner_only?(file_stat)
+    file_stat.owned? && ((file_stat.mode & 0xFFF) ^ 0O700) == 0
+  end
+
+  def run
+    process_to_output = {}
+    if can_execute_in_directory?(directory)
+      current = Dir[File.join(directory, "*")].map do |path|
+        full_path = File.expand_path(path)
+        if can_execute_file?(path)
+          stdin_r,  stdin_w  = IO.pipe
+          stdout_r, stdout_w = IO.pipe
+          stderr_r, stderr_w = IO.pipe
+
+          previous_status, previous_time, previous_output = previous[full_path]
+
+          stdin_w.write(previous_output || "")
+          stdin_w.close
+
+
+          cmd = [full_path, (previous_time || 0).to_i, (previous_status && previous_status.to_i)].compact.map(&:to_s)
+
+          pid = Process.spawn(*cmd,
+                              :chdir => File.dirname(full_path),
+                              :in    => stdin_r,
+                              :out   => stdout_w,
+                              :err   => stderr_w)
+
+          exit_status = nil
+          exec_time   = Benchmark.realtime do
+                          pid, exit_status = Process.wait2(pid)
+                        end
+
+          if exec_time > 1.0
+            puts "[SLOW SCRIPT] Time to execute process #{full_path} took #{exec_time} seconds"
+          end
+
+          [stdin_r, stdout_w, stderr_w].each(&:close)
+
+          output = stdout_r.read.to_s.chomp
+
+          stderr = stderr_r.read.to_s.chomp
+          unless stderr.empty?
+            puts "[STDERR] #{full_path} (PID:#{pid}) [#{Time.now.to_s}]:: #{stderr}"
+          end
+
+          [stdout_r, stderr_r].each(&:close)
+
+          [full_path, [exit_status, Time.now, output]]
+        else
+          if !File.directory?(full_path)
+            uid  = Process.uid
+            user = Etc.getpwuid(uid).name
+            puts "[INFO] Cannot execute #{full_path}, must be executable and only readable/writable by #{user}/#{uid}"
+          end
+          [full_path, []]
+        end
+      end
+      process_to_output = Hash[current]
+      @previous         = process_to_output
+    else
+      puts "Directory #{directory} has gone away or does not have the correct permissions (0700), not scanning for metric scripts."
+    end
+    process_to_output.flat_map do |path, (status, time, output)|
+      if status && status.success?
+        prefix = File.basename(path).split(".")[0..-2].join(".").gsub(/[^a-z0-9\-\_\.]/i, "_")
+        output.lines                                      # each line
+          .map    { |line| line.chomp.split }             # split by whitespace
+          .select { |data| (2..3).include?(data.size)  }  # and only valid name value time? pairs
+          .map    { |(name, value, specific_time)| [[prefix, name].join("."), value.to_f, (specific_time || time).to_i] } # with value coerced to a float
+      end
+    end.compact
+  end
+
+end

data/lib/instrumental_tools/server_controller.rb

@@ -0,0 +1,70 @@
+require 'pidly'
+require 'instrumental_tools/metric_script_executor'
+require 'instrumental_tools/system_inspector'
+
+class ServerController < Pidly::Control
+  COMMANDS = [:start, :stop, :status, :restart, :clean, :kill, :foreground]
+
+  attr_accessor :run_options, :pid
+
+  before_start do
+    extra_info = if run_options[:daemon]
+                   "(#{run_options[:pid_location]}), log: #{run_options[:log_location]}"
+                 end
+    puts "Starting daemon process: #{@pid} #{extra_info}"
+  end
+
+  start :foreground
+
+  stop do
+    puts "Attempting to kill daemon process: #{@pid}"
+  end
+
+  error do
+    puts 'Error encountered'
+  end
+
+  def self.run(options)
+    agent = Instrumental::Agent.new(options[:api_key], :collector => [options[:collector], options[:port]].compact.join(':'))
+    puts "instrument_server version #{Instrumental::Tools::VERSION} started at #{Time.now.utc}"
+    puts "Collecting stats under the hostname: #{options[:hostname]}"
+    report_interval = options[:report_interval]
+    custom_metrics  = MetricScriptExecutor.new(options[:script_location])
+    loop do
+      t = Time.now.to_i
+      next_run_at = (t - t % report_interval) + report_interval
+      sleep [next_run_at - t, 0].max
+      inspector = SystemInspector.new
+      inspector.load_all
+      count = 0
+      inspector.gauges.each do |stat, value|
+        metric = "#{options[:hostname]}.#{stat}"
+        agent.gauge(metric, value)
+        if options[:debug]
+          puts [metric, value].join(":")
+        end
+        count += 1
+      end
+      custom_metrics.run.each do |(stat, value, time)|
+        metric = "#{options[:hostname]}.#{stat}"
+        agent.gauge(metric, value, time)
+        if options[:debug]
+          puts [metric, value].join(":")
+        end
+        count += 1
+      end
+      puts "Sent #{count} metrics"
+    end
+  end
+
+  def initialize(options={})
+    @run_options = options.delete(:run_options) || {}
+    super(options)
+  end
+
+  def foreground
+    self.class.run(run_options)
+  end
+
+  alias_method :clean, :clean!
+end

data/lib/instrumental_tools/system_inspector/linux.rb

@@ -0,0 +1,146 @@
+class SystemInspector
+  module Linux
+    def self.load_cpu
+      output = { :gauges => {} }
+      output[:gauges].merge!(cpu)
+      output[:gauges].merge!(loadavg)
+      output
+    end
+
+    def self.cpu
+      categories = [:user, :nice, :system, :idle, :iowait]
+      values     = `cat /proc/stat | grep cpu[^0-9]`.chomp.split.slice(1, 5).map { |v| v.to_f }
+      SystemInspector.memory.store(:cpu_values, values.dup)
+      if previous_values = SystemInspector.memory.retrieve(:cpu_values)
+        index = -1
+        values.collect! { |value| (previous_values[index += 1] - value).abs }
+      end
+      data   = Hash[*categories.zip(values).flatten]
+      total  = values.inject { |memo, value| memo + value }
+
+      output = {}
+      if previous_values
+        data.each do |category, value|
+          output["cpu.#{category}"] = value / total * 100
+        end
+      end
+      output["cpu.in_use"] = 100 - data[:idle] / total * 100
+      output
+    end
+
+    def self.loadavg
+      min_1, min_5, min_15 = `cat /proc/loadavg`.split
+      {
+        'load.1min'  => min_1.to_f,
+        'load.5min'  => min_5.to_f,
+        'load.15min' => min_15.to_f
+      }
+    end
+
+    def self.load_memory
+      output = { :gauges => {} }
+      if SystemInspector.command_present?('free', 'memory')
+        output[:gauges].merge!(memory)
+      end
+      if SystemInspector.command_present?('free', 'swap')
+        output[:gauges].merge!(swap)
+      end
+      output
+    end
+
+    def self.memory
+      _, total, used, free, shared, buffers, cached = `free -k -o | grep Mem`.chomp.split
+      {
+        'memory.used_mb'      => used.to_f / 1024,
+        'memory.free_mb'      => free.to_f / 1024,
+        'memory.buffers_mb'   => buffers.to_f / 1024,
+        'memory.cached_mb'    => cached.to_f / 1024,
+        'memory.free_percent' => (free.to_f / total.to_f) * 100
+      }
+    end
+
+    def self.swap
+      _, total, used, free = `free -k -o | grep Swap`.chomp.split
+      return {} if total.to_i == 0
+      {
+        'swap.used_mb'      => used.to_f / 1024,
+        'swap.free_mb'      => free.to_f / 1024,
+        'swap.free_percent' => (free.to_f / total.to_f) * 100
+      }
+    end
+
+    def self.load_disks
+      output = { :gauges => {} }
+      if SystemInspector.command_present?('df', 'disk storage')
+        output[:gauges].merge!(disk_storage)
+      end
+      if SystemInspector.command_present?('mount', 'disk IO')
+        output[:gauges].merge!(disk_io)
+      end
+      output
+    end
+
+    def self.disk_storage
+      output = {}
+      `df -Pka`.lines.each do |line|
+        device, total, used, available, capacity, mount = line.chomp.split
+        if device == "tmpfs"
+          names = ["tmpfs_#{mount.gsub(/[^[:alnum:]]/, "_")}".gsub(/_+/, "_")]
+        elsif device =~ %r{/dev/}
+          names = [File.basename(device)]
+        else
+          next
+        end
+        names << 'root' if mount == '/'
+        names.each do |name|
+          output["disk.#{name}.total_mb"]          = total.to_f / 1024
+          output["disk.#{name}.used_mb"]           = used.to_f / 1024
+          output["disk.#{name}.available_mb"]      = available.to_f / 1024
+          output["disk.#{name}.available_percent"] = available.to_f / total.to_f * 100
+        end
+      end
+      output
+    end
+
+    def self.disk_io
+      output          = {}
+      mounted_devices = `mount`.lines.grep(/^\/dev\/(\w+)/) { $1 }
+      diskstats_lines = `cat /proc/diskstats`.lines.grep(/#{mounted_devices.join('|')}/)
+      entries         = diskstats_lines.map do |line|
+                          values              = line.chomp.split
+                          entry               = {}
+                          entry[:time]        = Time.now
+                          entry[:device]      = values[2]
+                          entry[:utilization] = values[12].to_f
+                          SystemInspector.memory.store("disk_stats_#{entry[:device]}".to_sym, entry)
+                        end
+
+      entries.each do |entry|
+        if previous_entry = SystemInspector.memory.retrieve("disk_stats_#{entry[:device]}".to_sym)
+          time_delta                                           = (entry[:time] - previous_entry[:time]) * 1000
+          utilization_delta                                    = entry[:utilization] - previous_entry[:utilization]
+          output["disk.#{entry[:device]}.percent_utilization"] = utilization_delta / time_delta * 100
+        end
+      end
+      output
+    end
+
+    def self.load_filesystem
+      output = { :gauges => {} }
+      if SystemInspector.command_present?('sysctl', 'filesystem')
+        output[:gauges].merge!(filesystem)
+      end
+      output
+    end
+
+    def self.filesystem
+      allocated, unused, max = `sysctl fs.file-nr`.split[-3..-1].map { |v| v.to_i }
+      open_files             = allocated - unused
+      {
+        'filesystem.open_files'         => open_files,
+        'filesystem.max_open_files'     => max,
+        'filesystem.open_files_pct_max' => (open_files.to_f / max.to_f) * 100
+      }
+    end
+  end
+end