sensu-plugins-docker-swarm 3.3.0

data/bin/metrics-docker-container.rb

@@ -0,0 +1,127 @@
+#! /usr/bin/env ruby
+#
+#   docker-container-metrics
+#
+# DESCRIPTION:
+#
+# OUTPUT:
+#   metric-data
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#
+# USAGE:
+#
+# metrics-docker-container.rb -H /var/run/docker.sock -n
+#   docker.host.sensu.sh.rss 1 1508825823
+#   docker.host.sensu.sh.vsize 1572864 1508825823
+#   docker.host.sensu.sh.nswap 0 1508825823
+#   docker.host.sensu.sh.pctmem 0.0 1508825823
+#   docker.host.sensu.sh.fd 0 1508825823
+#   docker.host.sensu.sh.cpu 0 1508825823
+#
+# metrics-docker-container.rb -H https://127.0.0.1:2376
+#   docker.host.ff5240e079488d248c021f8da5d13074a6a9db72ffaf1129eded445f4e16cf50.sh.rss 183 1508825793
+#   docker.host.ff5240e079488d248c021f8da5d13074a6a9db72ffaf1129eded445f4e16cf50.sh.vsize 4616192 1508825793
+#   docker.host.ff5240e079488d248c021f8da5d13074a6a9db72ffaf1129eded445f4e16cf50.sh.nswap 0 1508825793
+#   docker.host.ff5240e079488d248c021f8da5d13074a6a9db72ffaf1129eded445f4e16cf50.sh.pctmem 0.01 1508825793
+#   docker.host.ff5240e079488d248c021f8da5d13074a6a9db72ffaf1129eded445f4e16cf50.sh.fd 0 1508825793
+#   docker.host.ff5240e079488d248c021f8da5d13074a6a9db72ffaf1129eded445f4e16cf50.sh.cpu 0 1508825793
+#
+# NOTES:
+#
+# LICENSE:
+#   Copyright 2014 Michal Cichra. Github @mikz
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/metric/cli'
+require 'sensu-plugins-docker/client_helpers'
+require 'pathname'
+require 'sys/proctable'
+
+#
+# Docker Container Metrics
+#
+class DockerContainerMetrics < Sensu::Plugin::Metric::CLI::Graphite
+  option :scheme,
+         description: 'Metric naming scheme, text to prepend to metric',
+         short: '-s SCHEME',
+         long: '--scheme SCHEME',
+         default: "docker.#{Socket.gethostname}"
+
+  option :cgroup_path,
+         description: 'path to cgroup mountpoint',
+         short: '-c PATH',
+         long: '--cgroup PATH',
+         default: '/sys/fs/cgroup'
+
+  option :docker_host,
+         description: 'Docker API URI. https://host, https://host:port, http://host, http://host:port, host:port, unix:///path',
+         short: '-H DOCKER_HOST',
+         long: '--docker-host DOCKER_HOST'
+
+  option :cgroup_template,
+         description: 'cgroup_template',
+         short: '-T TPL_STRING',
+         long: '--cgroup-template TPL_STRING',
+         default: 'cpu/docker/%{container}/cgroup.procs'
+
+  option :friendly_names,
+         description: 'use friendly name if available',
+         short: '-n',
+         long: '--names',
+         boolean: true,
+         default: false
+
+  def run
+    @client = DockerApi.new(config[:docker_host])
+    container_metrics
+    ok
+  end
+
+  def container_metrics
+    cgroup = "#{config[:cgroup_path]}/#{config[:cgroup_template]}"
+
+    timestamp = Time.now.to_i
+    ps = Sys::ProcTable.ps.group_by(&:pid)
+    sleep(1)
+    ps2 = Sys::ProcTable.ps.group_by(&:pid)
+
+    fields = [:rss, :vsize, :nswap, :pctmem]
+
+    path = '/containers/json'
+    containers = @client.parse(path)
+
+    containers.each do |container|
+      path = Pathname(format(cgroup, container: container['Id']))
+      pids = path.readlines.map(&:to_i)
+
+      container_name = if config[:friendly_names]
+                         container['Names'][0].delete('/')
+                       else
+                         container['Id']
+                       end
+
+      processes = ps.values_at(*pids).flatten.compact.group_by(&:comm)
+      processes2 = ps2.values_at(*pids).flatten.compact.group_by(&:comm)
+
+      processes.each do |comm, process|
+        prefix = "#{config[:scheme]}.#{container_name}.#{comm}"
+        fields.each do |field|
+          output "#{prefix}.#{field}", process.map(&field).reduce(:+), timestamp
+        end
+        # this check requires a lot of permissions, even root maybe?
+        output "#{prefix}.fd", process.map { |p| p.fd.keys.count }.reduce(:+), timestamp
+
+        second = processes2[comm]
+        cpu = second.map { |p| p.utime + p.stime }.reduce(:+) - process.map { |p| p.utime + p.stime }.reduce(:+)
+        output "#{prefix}.cpu", cpu, timestamp
+      end
+    end
+  end
+end

data/bin/metrics-docker-info.rb

@@ -0,0 +1,65 @@
+#! /usr/bin/env ruby
+#
+#   metrics-docker-info
+#
+# DESCRIPTION:
+#
+# This check gather certain general stats from Docker (number of CPUs, number of containers, images...)
+# Supports the stats feature of the docker remote api ( docker server 1.5 and newer )
+# Supports connecting to docker remote API over Unix socket or TCP
+# Based on metrics-docker-stats by @paulczar
+#
+#
+# OUTPUT:
+#   metric-data
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#
+# USAGE:
+#   Gather stats using unix socket:
+#   metrics-docker-info.rb -H /var/run/docker.sock
+#
+#   Gather stats from localhost using HTTP:
+#   metrics-docker-info.rb -H localhost:2375
+#
+#   See metrics-docker-info.rb --help for full usage flags
+#
+# NOTES:
+#
+# LICENSE:
+#   Copyright 2017 Alfonso Casimiro. Github @alcasim
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/metric/cli'
+require 'sensu-plugins-docker/client_helpers'
+
+class DockerStatsMetrics < Sensu::Plugin::Metric::CLI::Graphite
+  option :scheme,
+         description: 'Metric naming scheme, text to prepend to metric',
+         short: '-s SCHEME',
+         long: '--scheme SCHEME',
+         default: "#{Socket.gethostname}.docker"
+
+  option :docker_host,
+         description: 'Docker API URI. https://host, https://host:port, http://host, http://host:port, host:port, unix:///path',
+         short: '-H DOCKER_HOST',
+         long: '--docker-host DOCKER_HOST'
+
+  def run
+    @timestamp = Time.now.to_i
+    @client = DockerApi.new(config[:docker_host])
+    path = '/info'
+    infolist = @client.parse(path)
+    filtered_list = infolist.select { |key, _value| key.match(/NCPU|NFd|Containers|Images|NGoroutines|NEventsListener|MemTotal/) }
+    filtered_list.each do |key, value|
+      output "#{config[:scheme]}.#{key}", value, @timestamp
+    end
+    ok
+  end
+end

data/bin/metrics-docker-stats.rb

@@ -0,0 +1,219 @@
+#! /usr/bin/env ruby
+#
+#   metrics-docker-stats
+#
+# DESCRIPTION:
+#
+# Supports the stats feature of the docker remote api ( docker server 1.5 and newer )
+# Supports connecting to docker remote API over Unix socket or TCP
+#
+#
+# OUTPUT:
+#   metric-data
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#
+# USAGE:
+#   Gather stats from all containers on a host using socket:
+#   metrics-docker-stats.rb -H /var/run/docker.sock
+#
+#   Gather stats from all containers on a host using HTTP:
+#   metrics-docker-stats.rb -H localhost:2375
+#
+#   Gather stats from a specific container using socket:
+#   metrics-docker-stats.rb -H /var/run/docker.sock -N 5bf1b82382eb
+#
+#   See metrics-docker-stats.rb --help for full usage flags
+#
+# NOTES:
+#
+# LICENSE:
+#   Copyright 2015 Paul Czarkowski. Github @paulczar
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/metric/cli'
+require 'sensu-plugins-docker/client_helpers'
+
+class Hash
+  def self.to_dotted_hash(hash, recursive_key = '')
+    hash.each_with_object({}) do |(k, v), ret|
+      key = recursive_key + k.to_s
+      if v.is_a? Hash
+        ret.merge! to_dotted_hash(v, key + '.')
+      else
+        ret[key] = v
+      end
+    end
+  end
+end
+
+class DockerStatsMetrics < Sensu::Plugin::Metric::CLI::Graphite
+  option :scheme,
+         description: 'Metric naming scheme, text to prepend to metric',
+         short: '-s SCHEME',
+         long: '--scheme SCHEME',
+         default: "#{Socket.gethostname}.docker"
+
+  option :container,
+         description: 'Name of container to collect metrics for',
+         short: '-N CONTAINER',
+         long: '--container-name CONTAINER',
+         default: ''
+
+  option :docker_host,
+         description: 'Docker API URI. https://host, https://host:port, http://host, http://host:port, host:port, unix:///path',
+         short: '-H DOCKER_HOST',
+         long: '--docker-host DOCKER_HOST'
+
+  option :friendly_names,
+         description: 'use friendly name if available',
+         short: '-n',
+         long: '--names',
+         boolean: true,
+         default: false
+
+  option :name_parts,
+         description: 'Partial names by spliting and returning at index(es).
+         eg. -m 3,4 my-docker-container-process_name-b2ffdab8f1aceae85300 for process_name.b2ffdab8f1aceae85300',
+         short: '-m index',
+         long: '--match index'
+
+  option :delim,
+         description: 'the deliminator to use with -m',
+         short: '-d',
+         long: '--deliminator',
+         default: '-'
+
+  option :environment_tags,
+         description: 'Name of environment variables on each container to be appended to metric name, separated by commas',
+         short: '-e ENV_VARS',
+         long: '--environment-tags ENV_VARS'
+
+  option :ioinfo,
+         description: 'enable IO Docker metrics',
+         short: '-i',
+         long: '--ioinfo',
+         boolean: true,
+         default: false
+
+  option :cpupercent,
+         description: 'add cpu usage percentage metric',
+         short: '-P',
+         long: '--percentage',
+         boolean: true,
+         default: false
+
+  def run
+    @timestamp = Time.now.to_i
+    @client = DockerApi.new(config[:docker_host])
+
+    list = if config[:container] != ''
+             [config[:container]]
+           else
+             list_containers
+           end
+    list.each do |container|
+      stats = container_stats(container)
+      scheme = ''
+      unless config[:environment_tags].nil?
+        scheme << container_tags(container)
+      end
+      if config[:name_parts]
+        config[:name_parts].split(',').each do |key|
+          scheme << '.' unless scheme == ''
+          scheme << container.split(config[:delim])[key.to_i]
+        end
+      else
+        scheme << container
+      end
+      output_stats(scheme, stats)
+    end
+    ok
+  end
+
+  def output_stats(container, stats)
+    dotted_stats = Hash.to_dotted_hash stats
+    dotted_stats.each do |key, value|
+      next if key == 'read' # unecessary timestamp
+      next if value.is_a?(Array)
+      value.delete!('/') if key == 'name'
+      output "#{config[:scheme]}.#{container}.#{key}", value, @timestamp
+    end
+    if config[:ioinfo]
+      blkio_stats(stats['blkio_stats']).each do |key, value|
+        output "#{config[:scheme]}.#{container}.#{key}", value, @timestamp
+      end
+    end
+    output "#{config[:scheme]}.#{container}.cpu_stats.usage_percent", calculate_cpu_percent(stats), @timestamp if config[:cpupercent]
+  end
+
+  def list_containers
+    list = []
+    path = '/containers/json'
+    containers = @client.parse(path)
+
+    containers.each do |container|
+      list << if config[:friendly_names]
+                container['Names'][-1].delete('/')
+              elsif config[:name_parts]
+                container['Names'][-1].delete('/')
+              else
+                container['Id']
+              end
+    end
+    list
+  end
+
+  def container_stats(container)
+    path = "/containers/#{container}/stats?stream=0"
+    response = @client.call(path)
+    if response.code.to_i == 404
+      critical "#{config[:container]} is not running on #{@client.uri}"
+    end
+    parse_json(response)
+  end
+
+  def container_tags(container)
+    tags = ''
+    path = "/containers/#{container}/json"
+    response = @client.call(path)
+    if response.code.to_i == 404
+      critical "#{config[:container]} is not running on #{@client.uri}"
+    end
+    inspect = parse_json(response)
+    tag_list = config[:environment_tags].split(',')
+    tag_list.each do |value|
+      tags << inspect['Config']['Env'].select { |tag| tag.to_s.match(/#{value}=/) }.first.to_s.gsub(/#{value}=/, '') + '.'
+    end
+    tags
+  end
+
+  def blkio_stats(io_stats)
+    stats_out = {}
+    io_stats.each do |stats_type, stats_vals|
+      stats_vals.each do |value|
+        stats_out["#{stats_type}.#{value['op']}.#{value['major']}.#{value['minor']}"] = value['value']
+      end
+    end
+    stats_out
+  end
+
+  def calculate_cpu_percent(stats)
+    cpu_percent = 0.0
+    previous_cpu = stats['precpu_stats']['cpu_usage']['total_usage']
+    previous_system = stats['precpu_stats']['system_cpu_usage']
+    cpu_delta = stats['cpu_stats']['cpu_usage']['total_usage'] - previous_cpu
+    system_delta = stats['cpu_stats']['system_cpu_usage'] - previous_system
+    if system_delta > 0 && cpu_delta > 0
+      number_of_cpu = stats['cpu_stats']['cpu_usage']['percpu_usage'].length
+      cpu_percent = (cpu_delta.to_f / system_delta.to_f) * number_of_cpu * 100
+    end
+    format('%.2f', cpu_percent)
+  end
+end

data/lib/sensu-plugins-docker.rb

@@ -0,0 +1 @@
+require 'sensu-plugins-docker/version'

data/lib/sensu-plugins-docker/client_helpers.rb

@@ -0,0 +1,60 @@
+require 'net_http_unix'
+require 'json'
+
+class DockerApi
+  def initialize(uri = nil)
+    @client = nil
+    @docker_uri = uri || ENV['DOCKER_URL'] || ENV['DOCKER_HOST'] || '/var/run/docker.sock'
+    if @docker_uri.sub!(%r{^(unix://)?/}, '')
+      @docker_uri = 'unix:///' + @docker_uri
+      @client = NetX::HTTPUnix.new(@docker_uri)
+    else
+      protocol = %r{^(https?|tcp)://}.match(@docker_uri) || 'http://'
+      @docker_uri.sub!(protocol.to_s, '')
+      split_host = @docker_uri.split ':'
+      @client = if split_host.length == 2
+                  NetX::HTTPUnix.new("#{protocol}#{split_host[0]}", split_host[1])
+                else
+                  NetX::HTTPUnix.new("#{protocol}#{@docker_uri}", 2375)
+                end
+    end
+    @client.start
+  end
+
+  def uri
+    @docker_uri
+  end
+
+  def call(path, halt = true, limit = 10)
+    raise ArgumentError, "HTTP redirect too deep. Last url called : #{path}" if limit.zero?
+    if %r{^unix:///} =~ @docker_uri
+      request = Net::HTTP::Get.new path.to_s
+    else
+      uri = URI("#{@docker_uri}#{path}")
+      request = Net::HTTP::Get.new uri.request_uri
+    end
+    response = @client.request(request)
+    case response
+    when Net::HTTPSuccess     then response
+    when Net::HTTPRedirection then call(response['location'], true, limit - 1)
+    else
+      return response.error! unless halt == false
+      return response
+    end
+  end
+
+  def parse(path, halt = true, limit = 10)
+    parsed = parse_json(call(path, halt, limit))
+    parsed
+  end
+end
+
+def parse_json(response)
+  parsed = nil
+  begin
+    parsed = JSON.parse(response.read_body)
+  rescue JSON::ParserError => e
+    raise "JSON Error: #{e.inspect}"
+  end
+  parsed
+end