sensu-plugins-docker-swarm 3.3.0

data/bin/check-container.rb

@@ -0,0 +1,93 @@
+#! /usr/bin/env ruby
+#
+#   check-container
+#
+# DESCRIPTION:
+#   This is a simple check script for Sensu to check that a Docker container is
+#   running. You can pass in either a container id or a container name.
+#
+# OUTPUT:
+#   plain text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#
+# USAGE:
+#   check-container.rb -H /var/run/docker.sock -N c92d402a5d14
+#   CheckDockerContainer OK: c92d402a5d14 is running on /var/run/docker.sock.
+#
+#   check-container.rb -H https://127.0.0.1:2376 -N circle_burglar
+#   CheckDockerContainer CRITICAL: circle_burglar is not running on https://127.0.0.1:2376
+#
+# NOTES:
+#     => State.running == true   -> OK
+#     => State.running == false  -> CRITICAL
+#     => Not Found               -> CRITICAL
+#     => Can't connect to Docker -> WARNING
+#     => Other exception         -> WARNING
+#
+# LICENSE:
+#   Copyright 2014 Sonian, Inc. and contributors. <support@sensuapp.org>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'sensu-plugins-docker/client_helpers'
+
+#
+# Check Docker Container
+#
+class CheckDockerContainer < Sensu::Plugin::Check::CLI
+  option :docker_host,
+         short: '-H DOCKER_HOST',
+         long: '--docker-host DOCKER_HOST',
+         description: 'Docker API URI. https://host, https://host:port, http://host, http://host:port, host:port, unix:///path'
+
+  option :container,
+         short: '-N CONTAINER',
+         long: '--container-name CONTAINER',
+         required: true
+
+  option :tag,
+         short: '-t TAG',
+         long: '--tag TAG'
+
+  option :allowexited,
+         short: '-x',
+         long: '--allow-exited',
+         boolean: true,
+         description: 'Do not raise alert if container has exited without error'
+
+  def run
+    @client = DockerApi.new(config[:docker_host])
+    path = "/containers/#{config[:container]}/json"
+    response = @client.call(path, false)
+    if response.code.to_i == 404
+      critical "Container #{config[:container]} is not running on #{@client.uri}"
+    end
+    body = parse_json(response)
+    container_running = body['State']['Running']
+    if container_running
+      if config[:tag]
+        image = body['Config']['Image']
+        match = image.match(/^(?:([^\/]+)\/)?(?:([^\/]+)\/)?([^@:\/]+)(?:[@:](.+))?$/)
+        unless match && match[4] == config[:tag]
+          critical "#{config[:container]}'s tag is '#{match[4]}', especting '#{config[:tag]}'"
+        end
+      end
+      ok "#{config[:container]} is running on #{@client.uri}."
+    elsif config[:allowexited] && body['State']['Status'] == 'exited'
+      if (body['State']['ExitCode']).zero?
+        ok "#{config[:container]} has exited without error on #{@client.uri}."
+      else
+        critical "#{config[:container]} has exited with status code #{body['State']['ExitCode']} on #{@client.uri}."
+      end
+    else
+      critical "#{config[:container]} is #{body['State']['Status']} on #{@client.uri}."
+    end
+  end
+end

data/bin/check-docker-container.rb

@@ -0,0 +1,108 @@
+#! /usr/bin/env ruby
+#
+#   check-docker-container
+#
+# DESCRIPTION:
+# This is a simple check script for Sensu to check the number of a Docker Container
+#
+# OUTPUT:
+#   plain text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: net_http_unix
+#
+# USAGE:
+#   check-docker-container.rb -w 3 -c 3
+#   => 1 container running = OK.
+#   => 4 container running = CRITICAL
+#
+#   check-docker-container.rb -H /var/run/docker.sock -w 3 -c 3
+#   => 1 container running = OK.
+#   => 4 container running = CRITICAL
+#
+#   check-docker-container.rb -H https://127.0.0.1:2376  -w 3 -c 3
+#   => 1 container running = OK.
+#   => 4 container running = CRITICAL
+#
+# NOTES:
+#
+# LICENSE:
+#   Author Yohei Kawahara  <inokara@gmail.com>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'sensu-plugins-docker/client_helpers'
+
+#
+# Check Docker Containers
+#
+class CheckDockerContainers < Sensu::Plugin::Check::CLI
+  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 :warn_over,
+         short: '-W N',
+         long: '--warn-over N',
+         description: 'Trigger a warning if over a number',
+         proc: proc(&:to_i)
+
+  option :crit_over,
+         short: '-C N',
+         long: '--critical-over N',
+         description: 'Trigger a critical if over a number',
+         proc: proc(&:to_i)
+
+  option :warn_under,
+         short: '-w N',
+         long: '--warn-under N',
+         description: 'Trigger a warning if under a number',
+         proc: proc(&:to_i),
+         default: 1
+
+  option :crit_under,
+         short: '-c N',
+         long: '--critical-under N',
+         description: 'Trigger a critical if under a number',
+         proc: proc(&:to_i),
+         default: 1
+
+  def under_message(crit_under, count)
+    "Less than #{crit_under} containers running. #{count} running."
+  end
+
+  def over_message(crit_over, count)
+    "More than #{crit_over} containers running. #{count} running."
+  end
+
+  def evaluate_count(count)
+    # #YELLOW
+    if config.key?(:crit_under) && count < config[:crit_under]
+      critical under_message(config[:crit_under], count)
+    # #YELLOW
+    elsif config.key?(:crit_over) && count > config[:crit_over]
+      critical over_message(config[:crit_over], count)
+    # #YELLOW
+    elsif config.key?(:warn_under) && count < config[:warn_under]
+      warning under_message(config[:warn_under], count)
+    # #YELLOW
+    elsif config.key?(:warn_over) && count > config[:warn_over]
+      warning over_message(config[:warn_over], count)
+    else
+      ok
+    end
+  end
+
+  def run
+    @client = DockerApi.new(config[:docker_host])
+    containers = @client.parse('/containers/json')
+    evaluate_count containers.size
+  end
+end

data/bin/check-service-logs.rb

@@ -0,0 +1,199 @@
+#! /usr/bin/env ruby
+#
+#   check-service-logs
+#
+# DESCRIPTION:
+#   Checks docker logs for specified strings
+#   with the option to ignore lines if they contain specified substrings.
+#
+# OUTPUT:
+#   plain text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: net_http_unix
+#
+# USAGE:
+#   # Check only one service
+#   check-service-logs.rb -H /tmp/docker.sock -N logspout -r 'problem sending' -r 'i/o timeout' -i 'Remark:' -i 'The configuration is'
+#   => 1 service running = OK
+#   => 4 service running = CRITICAL
+#
+#   # Check multiple services
+#   check-service-logs.rb -H /tmp/docker.sock -N logspout -N logtest -r 'problem sending' -r 'i/o timeout' -i 'Remark:' -i 'The configuration is'
+#   => 1 service running = OK
+#   => 4 service running = CRITICAL
+#
+#   # Check all services
+#   check-service-logs.rb -H /tmp/docker.sock -r 'problem sending' -r 'i/o timeout' -i 'Remark:' -i 'The configuration is'
+#   => 1 services running = OK
+#   => 4 services running = CRITICAL
+#
+# NOTES:
+#   The API parameter required to use the limited lookback (-t) was introduced
+#   the Docker server API version 1.19. This check may still work on older API
+#   versions if you don't want to limit the timestamps of logs.
+#
+# LICENSE:
+#   Author: Nathan Newman  <newmannh@gmail.com>, Kel Cecil <kelcecil@praisechaos.com>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'sensu-plugins-docker/client_helpers'
+
+class ServiceLogChecker < Sensu::Plugin::Check::CLI
+  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 :service,
+         description: 'name of service; can be used multiple times. /!\ All running services will be check if this options is not provided',
+         short: '-N service',
+         long: '--service-name service',
+         default: [],
+         proc: proc { |flag| (@options[:service][:accumulated] ||= []).push(flag) }
+
+  option :red_flags,
+         description: 'String whose presence (case-insensitive by default) in a log line indicates an error; can be used multiple times',
+         short: '-r ERR_STRING',
+         long: '--red-flag ERR_STRING',
+         default: [],
+         proc: proc { |flag| (@options[:red_flags][:accumulated] ||= []).push(flag) }
+
+  option :ignore_list,
+         description: 'String whose presence (case-insensitive by default) in a log line indicates the line should be ignored; can be used multiple times',
+         short: '-i IGNSTR',
+         long: '--ignore-lines-with IGNSTR',
+         default: [],
+         proc: proc { |flag| (@options[:ignore_list][:accumulated] ||= []).push(flag) }
+
+  option :case_sensitive,
+         description: 'indicates all red_flag and ignore_list substring matching should be case-sensitive instead of the default case-insensitive',
+         short: '-c',
+         long: '--case-sensitive',
+         boolean: true
+
+  option :hours_ago,
+         description: 'Amount of time in hours to look back for log strings',
+         short: '-t HOURS',
+         long: '--hours-ago HOURS',
+         required: false
+
+  option :seconds_ago,
+         description: 'Amount of time in seconds to look back for log strings',
+         short: '-s SECONDS',
+         long: '--seconds-ago SECONDS',
+         required: false
+
+  option :check_all,
+         description: 'If all services are checked (no service name provided with -n) , check offline services too',
+         short: '-a',
+         long: '--all',
+         default: false,
+         boolean: true
+
+  option :disable_stdout,
+         description: 'Disable the check on STDOUT logs. By default both STDERR and STDOUT are checked',
+         short: '-1',
+         long: '--no-stdout',
+         default: true,
+         boolean: true,
+         proc: proc { false } # used to negate the false(default)->true boolean option behaviour to true(default)->false
+
+  option :disable_stderr,
+         description: 'Disable the check on STDERR logs. By default both STDERR and STDOUT are checked',
+         short: '-2',
+         long: '--no-stderr',
+         default: true,
+         boolean: true,
+         proc: proc { false } # used to negate the false(default)->true boolean option behaviour to true(default)->false
+
+  def calculate_timestamp(seconds_ago = nil)
+    seconds_ago = yield if block_given?
+    (Time.now - seconds_ago).to_i
+  end
+
+  def process_docker_logs(service_name)
+    path = "/services/#{service_name}/logs?stdout=#{config[:disable_stdout]}&stderr=#{config[:disable_stderr]}&timestamps=true"
+    if config.key? :hours_ago
+      timestamp = calculate_timestamp { config[:hours_ago].to_i * 3600 }
+    elsif config.key? :seconds_ago
+      timestamp = calculate_timestamp config[:seconds_ago].to_i
+    end
+    path = "#{path}&since=#{timestamp}"
+    response = @client.call(path, false)
+    if response.code.to_i == 404
+      critical "service '#{service_name}' not found on #{@client.uri}"
+    end
+    yield remove_headers response.read_body
+  end
+
+  def remove_headers(raw_logs)
+    lines = raw_logs.split("\n")
+    lines.map! do |line|
+      # Check only logs generated with the 8 bits control
+      if !line.nil? && line.bytesize > 8 && /^(0|1|2)000$/ =~ line.byteslice(0, 4).unpack('C*').join('')
+        # Remove the first 8 bits and ansii colors too
+        line.byteslice(8, line.bytesize).gsub(/\x1b\[[\d;]*?m/, '')
+      end
+    end
+    # We want the most recent logs lines first
+    lines.compact.reverse.join("\n")
+  end
+
+  def includes_any?(str, array_of_substrings)
+    array_of_substrings.each do |substring|
+      return true if str.include? substring
+    end
+    false
+  end
+
+  def detect_problem(logs)
+    whiteflags = config[:ignore_list]
+    redflags = config[:red_flags]
+    unless config[:case_sensitive]
+      logs = logs.downcase
+      whiteflags.map!(&:downcase)
+      redflags.map!(&:downcase)
+    end
+
+    logs.split("\n").each do |line|
+      return line if !includes_any?(line, whiteflags) && includes_any?(line, redflags)
+    end
+    nil
+  end
+
+  def run
+    @client = DockerApi.new(config[:docker_host])
+    problem = []
+    problem_string = nil
+    path = "/services/json?all=#{config[:check_all]}"
+    services = config[:service]
+    if config[:service].none?
+      warn_msg = %(
+        Collecting logs from all services is dangerous and could lead to sensu client hanging depending on volume of logs.
+        This not recommended for production environments.
+      ).gsub(/\s+/, ' ').strip
+      message warn_msg
+    end
+    services = @client.parse(path).map { |p| p['Names'][0].delete('/') } if services.none?
+    critical 'Check all services was asked but no services was found' if services.none?
+    services.each do |service|
+      process_docker_logs service do |log_chunk|
+        problem_string = detect_problem(log_chunk)
+        break unless problem_string.nil?
+      end
+      problem << "\tError found inside service : '#{service}'\n\t\t#{problem_string}" unless problem_string.nil?
+    end
+    problem_string = problem.join("\n")
+    critical "service(s) logs indicate problems :\n#{problem_string}" unless problem.none?
+    services_string = services.join(', ')
+    ok "No errors detected from logs inside service(s) : \n#{services_string}"
+  end
+end

data/bin/check-service.rb

@@ -0,0 +1,102 @@
+#! /usr/bin/env ruby
+#
+#   check-service
+#
+# DESCRIPTION:
+#   This is a simple check script for Sensu to check that a Docker service is
+#   running all of it's intended tasks. You can pass in either a service id or a service name.
+#
+# OUTPUT:
+#   plain text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#
+# USAGE:
+#   check-service.rb -H /var/run/docker.sock -N c92d402a5d14
+#   CheckDockerService OK: c92d402a5d14 is running on /var/run/docker.sock.
+#
+#   check-service.rb -H https://127.0.0.1:2376 -N circle_burglar
+#   CheckDockerService CRITICAL: circle_burglar is not running on https://127.0.0.1:2376
+#
+# NOTES:
+#     => .Replicas == number of service's tasks -> OK
+#     => .Replicas != number of service's tasks -> CRITICAL
+#     => Not Found                              -> CRITICAL
+#     => Can't connect to Docker                -> WARNING
+#     => Other exception                        -> WARNING
+#
+# LICENSE:
+#   Copyright 2014 Sonian, Inc. and contributors. <support@sensuapp.org>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'sensu-plugins-docker/client_helpers'
+
+#
+# Check Docker Service
+#
+class CheckDockerService < Sensu::Plugin::Check::CLI
+  option :docker_host,
+         short: '-H DOCKER_HOST',
+         long: '--docker-host DOCKER_HOST',
+         description: 'Docker API URI. https://host, https://host:port, http://host, http://host:port, host:port, unix:///path'
+
+  option :service,
+         short: '-N SERVICE',
+         long: '--service-name service',
+         required: true
+
+  option :tag,
+         short: '-t TAG',
+         long: '--tag TAG'
+
+  option :allowexited,
+         short: '-x',
+         long: '--allow-exited',
+         boolean: true,
+         description: 'Do not raise alert if service has exited without error'
+
+  def run
+    # Connect a client to the remote/local docker socket
+    @client = DockerApi.new(config[:docker_host])
+
+    # Call /services and get the service we want to check
+    path = "/services?filters=%7B%22name%22%3A%7B%22#{config[:service]}%22%3Atrue%7D%7D"
+    response = @client.call(path, false)
+    if response.code.to_i == 404
+      critical "service #{config[:service]} is not running on #{@client.uri} bb"
+    end
+
+    # Pass the number of replicas the service should be running
+    body = parse_json(response)
+    intended_replicas = body[0]['Spec']['Mode']['Replicated']['Replicas']
+
+    # Call /tasks to get the number of running replicas (this is how `docker service ls` works)
+    running_replicas = 0
+    path = "/tasks?filters=%7B%22name%22%3A%7B%22#{config[:service]}%22%3Atrue%7D%7D"
+    response = @client.call(path, false)
+    if response.code.to_i == 404
+      critical "service #{config[:service]} is not running on #{@client.uri}, tasks not found"
+    end
+
+    # Traverse the tasks and check if the state is running
+    tasks = parse_json(response)
+    tasks.each do |task|
+      if task['Status']['State'] == 'running'
+        running_replicas += 1
+      end
+    end
+
+    # If the number of running replicas is not what the service expects, return critical
+    if intended_replicas != running_replicas
+      critical "service #{config[:service]} is not running the intended number of replicas"
+    end
+    ok "#{config[:service]} is running correctly on #{@client.uri}."
+  end
+end