sensu-plugin-collectd 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dd0018fa8411d7d0d1d4c4c2f3f3318cd1d2049e
+  data.tar.gz: 27988bf80e4aa802886b2221448670e354998a8d
+SHA512:
+  metadata.gz: bedd741b536d70648592a5fc9a41b6a0fae81a646ad96df59178f4c081d5ecec5490f2dbdfafa3e542a13a1c67117e77ad423dec2ee462acf844b0fcc75d95fc
+  data.tar.gz: 6eda7d5fdffd59bc5bf0ffdaf524b3bff9250a3394ca8d4275e64b88a910216a9c2e9b46e3a6706f3a6f36e828e07d5f96316045b45d366784c5ad523ee5933e

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+.idea/*
+*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,120 @@
+# sensu-plugin-collectd
+Sensu plugin that reads a particular metric from collectd, using the collectd
+socket, and ensures that it is bellow the given critical and warning thresholds.
+If it is not, it will generate either a critical or warning alert in sensu. 
+Otherwise, it will generate a sensu ok.
+
+See:
+https://github.com/sensu-plugins
+
+## Installation
+Use the latest version of the `check-collectd-socket-metric.rb` from releases.
+See the [sensu installation instructions](http://sensu-plugins.io/docs/installation_instructions.html)
+
+## Collectd: what you need to know to use this plugin
+To use this sensu check you need to be at least vaguely familiar with collectd. You can check [the docs](https://collectd.org/documentation.shtml). What you will need to know is the name of the metric, and the metric from the list you want to alert on. If you want to see all the metrics available in a machine:
+
+```
+~$ collectdctl LISTVAL
+server-name-1-ip-172-1-2-3/collectd-cache/cache_size
+server-name-1-ip-172-1-2-3/collectd-write_queue/derive-dropped
+server-name-1-ip-172-1-2-3/collectd-write_queue/queue_length
+server-name-1-ip-172-1-2-3/contextswitch/contextswitch
+server-name-1-ip-172-1-2-3/cpu-0/cpu-idle
+server-name-1-ip-172-1-2-3/cpu-0/cpu-interrupt
+server-name-1-ip-172-1-2-3/cpu-0/cpu-nice
+server-name-1-ip-172-1-2-3/cpu-0/cpu-softirq
+server-name-1-ip-172-1-2-3/cpu-0/cpu-steal
+server-name-1-ip-172-1-2-3/cpu-0/cpu-system
+server-name-1-ip-172-1-2-3/cpu-0/cpu-user
+server-name-1-ip-172-1-2-3/cpu-0/cpu-wait
+server-name-1-ip-172-1-2-3/cpu-1/cpu-idle
+server-name-1-ip-172-1-2-3/cpu-1/cpu-interrupt
+server-name-1-ip-172-1-2-3/cpu-1/cpu-nice
+server-name-1-ip-172-1-2-3/cpu-1/cpu-softirq
+server-name-1-ip-172-1-2-3/cpu-1/cpu-steal
+server-name-1-ip-172-1-2-3/cpu-1/cpu-system
+server-name-1-ip-172-1-2-3/cpu-1/cpu-user
+server-name-1-ip-172-1-2-3/cpu-1/cpu-wait
+
+[...]
+```
+
+To query a particular metric:
+```
+~$ collectdctl GETVAL server-name-1-ip-172-1-2-3//processes-logstash/ps_count
+processes=1.000000e+00
+threads=7.900000e+01
+```
+
+If you want to alert on `server-name-1-ip-172-1-2-3/collectd-cache/cache_size`, youwill need to pass down the metric `collectd-cache/cache_size`
+
+## Usage
+You can run the following to display the help
+```
+check-collectd-socket-metric.rb -h
+```
+
+You will need to provide a warning threshold and a critical threshold, a metric ID or a regular expresion to match the metric. Optionally, you can also provide a value for the metric (if the metric id will return a list of metrics). But default it will alert on `value`
+
+### Mandatory parameters
+1. Metric id (-m --metric) or regular expression (-r --regexp). One, and only one of them must be provided.
+
+If you want to alert on `server-name-1-ip-172-1-2-3/collectd-cache/cache_size`, youwill need to pass down the metric `-m collectd-cache/cache_size`
+
+Alternative, a very simple regular expresion can be used: you can use `*` as a wildcard to match serveral metrics, and alert on the highest value of all of them. Only `*` as a wildcard is supported and tested. Anything else can produce unexpected behaviour. You can find an example at the end of this document. Please, ensure you test the regular expression (manually run the check) before starting to use it.
+
+2. Warning threshold (-w --warning): warning threshold to alert on. If the metric is higher than the warning threshold, the plugin will send a warning to sensu.
+
+3. Critical threshold (-c --critical): critical threshold to alert on. If the metric is higher than the critical threshold, the plugin will send a critical to sensu. It will only send a critical, and not a critical and a warning.
+
+### Optional parameters
+
+1. Path to the collectd socket (-s --socket). By default `/var/run/collectd-unisock`. If it is in a different location, this option can be used to change it.
+2. Timeout (-t --timeout). 20 seconds by default. The check will timeout if it runs more than the timeout limit, sending a critical to sensu. It is provided in seconds.
+3. Metric value from the metric list (-d --data_name). By default, it is `value`. If there are multiple values and we need to select one, we can use this option.
+
+
+
+### Examples
+* Alerting on a single metric
+If you want to alert on `server-name-1-ip-172-1-2-3/collectd-cache/cache_size`, you will need to pass down the metric `collectd-cache/cache_size`
+```bash
+collectd_plugin.rb -m /uptime/uptime   -c 200400 -w 190000
+```
+We can expect an output like:
+```bash
+CheckCollectdSocket CRITICAL: host-name_1-ip-172-1-2-3/uptime/uptime[value] =  = 192291.00 is over the warning limit (190000.00)
+```
+
+* Alerting in a set of metrics
+If for example, we have 8 CPUs, and we want to alert if any of them goes above certain usage, we can use the regexp option:
+```bash
+ collectd_plugin.rb -r "cpu-*/cpu-idle" -c 99 -w 80
+```
+We can expect an output like:
+```bash
+CheckCollectdSocket WARNING: clickhouse-server-shard_1-ip-172-26-161-164/cpu-4/cpu-idle[value] = 97.93 is over the warning limit (80.00)
+```
+
+*. Specifying a different metric value
+If we have a ps_count metric that will return processes and threads, we can alert on the number of threads by setting the data_name:
+```bash
+collectd_plugin.rb -m processes-collectd/ps_count -c 10 -w 8 -d threads
+```
+It will return something like this:
+```bash
+CheckCollectdSocket CRITICAL: clickhouse-server-shard_1-ip-172-26-161-164/processes-collectd/ps_count[threads] = 12.00 is over the critical limit (10.00)
+```
+
+*. Changing the socket path
+If the collectd socket is in a different location to the default, we can set it:
+```bash
+collectd_plugin.rb -m processes-collectd/ps_count -c 10 -w 8 -d threads -s /var/run/collectd-unisock
+```
+
+*. Changing the default timeout
+We can set a custom timeout for the check with --timeout (seconds)
+```bash
+collectd_plugin.rb -m processes-collectd/ps_count -c 10 -w 8 -d threads -t 10
+```

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/check-collectd-socket-metric.rb

@@ -0,0 +1,467 @@
+#!/usr/bin/env ruby
+#
+#   check-collectd-socket-metric.rb
+#
+# DESCRIPTION:
+#   This plugin retrieves a metric from the collectd socket, and verifies
+#   that it is within the provided thresholds (critical and warning)
+#
+# OUTPUT:
+#   plain text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: rspec (for the tests)
+#
+# USAGE:
+#   check-collectd-socket-metric.rb (-m <metric_id> | -r <metric id regexp>)
+#      -w <warning threshold> -c <critical threshold> [-d <metric value>]
+#      [-t <timeout>] [-s <socket path>]
+#
+# LICENSE:
+#   Copyright: Maria Pilar Gomez Moya (mp.gomezmoya@gmail.com) and Bartosz Lassak
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'net/http'
+require 'socket'
+require 'timeout'
+
+# Encapsulates the interaction with the IOBuffer so we can have something
+# we can mock in the tests, something that we can open and close (effectively
+# clearing the buffer) and is more decaupled from the main class
+class SocketWrapper
+  attr_reader :socket_path
+
+  def initialize(
+      socket_path
+  )
+    @socket = nil
+    @socket_path = socket_path
+  end
+
+  def open
+    @socket = Net::BufferedIO.new(UNIXSocket.new(@socket_path))
+  end
+
+  def close
+    if @socket != nil
+      @socket.close
+    end
+  end
+
+  def readline
+    return @socket.readline
+  end
+
+  def write(line)
+    return @socket.write(line)
+  end
+end
+
+# Class with all the logic, separate from the actual Sensu Check, so it can be
+# properly tested
+class CheckCollectdComponent
+  def initialize(
+      socket,
+      critical,
+      warning,
+      metric,
+      regexp,
+      data_name,
+      timeout,
+      cli_handler
+  )
+    @socket = socket
+    @critical = critical
+    @warning = warning
+    @metric = metric
+    @regexp = regexp
+    @data_name = data_name
+    @timeout = timeout
+    @cli_handler = cli_handler
+    @is_regexp = false
+  end
+
+  def critical(message)
+    if @cli_handler != nil
+      @cli_handler.critical message
+    end
+    if @socket != nil
+      @socket.close
+    end
+  end
+
+  def warning(message)
+    if @cli_handler != nil
+      @cli_handler.warning message
+    end
+    if @socket != nil
+      @socket.close
+    end
+  end
+
+  def ok(message)
+    @cli_handler.ok message
+    @socket.close
+  end
+
+  def isFloat(string_option)
+    # We want to know if the option passed down in command line can be
+    # safely converted to a valid float. If not, we want to catch the
+    # exception and return an error, finishing the script.
+    begin
+      return !!Float(string_option)
+    rescue
+      return false
+    end
+  end
+
+  def formatedFloatString(float_number)
+    return "#{float_number.round(2)}"
+  end
+
+  # Verifies that the class attributes are valid: that they are not nil,
+  # and they are the expected data type (so we are not trying to use
+  # strings in the place of integers)
+  def validateArguments()
+    # XXX extract error messages to different file
+    # NULL checks
+    if @metric == nil and @regexp == nil
+      return false, "Metric and regexp can't be both empty"
+    end
+    if @socket == nil
+      return false, "The socket can't be empty"
+    end
+    if @critical == nil
+      return false, "Critical can't be empty"
+    end
+    if @warning == nil
+      return false, "Warning can't be empty"
+    end
+    if @data_name == nil
+      return false, "Data name can't be empty"
+    end
+    if @timeout == nil
+      return false, "Timeout can't be empty"
+    end
+    if @cli_handler == nil
+      return false, "The cli handler can't be empty"
+    end
+    # Validate data type
+    if !self.isFloat(@critical)
+      return false, "Critical has to be a number"
+    elsif @critical.to_f < 0
+      return false, "Critical has to be a positive number"
+    end
+    if !self.isFloat(@warning)
+      return false, "Warning has to be a number"
+    elsif @warning.to_f < 0
+      return false, "Warning has to be a positive number"
+    end
+    if !self.isFloat(@timeout)
+      return false, "Timeout has to be a number"
+    elsif @timeout.to_f < 0
+      return false, "Timeout has to be a positive number"
+    end
+    if @metric != nil and !(@metric.instance_of? String)
+      return false, "Metric has to be a string"
+    end
+    if @regexp != nil and !(@regexp.instance_of? String)
+      return false, "Regexp has to be a string"
+    end
+    # Validate that metric and regexp are not both set at the same time
+    if (@metric != nil and @metric != "") and (@regexp != nil and @regexp != "")
+      return false, "Only one of the options, metric or regexp, can be provided"
+    end
+    return true, ""
+  end
+
+  # Formats arguments and ensures that they have the correct data type
+  def formatArguments()
+    self.prependSlashInMetric
+    @critical = @critical.to_f
+    @warning = @warning.to_f
+    @timeout = @timeout.to_f
+    if @regexp != nil and @regexp != ""
+      @is_regexp = true
+    end
+  end
+
+  # Reads the first line of the results of either GETVAL or LISTVAL
+  # and parses the number of lines that need to be read
+  #
+  # Returns the number of lines to be read in the socket
+  def getNumResultsInSocket(line)
+    # The first line will be the number of results in the format
+    # "XXX Values found". We need that number to loop and parse every single entry
+    # end
+    return (line.strip.split(" ")[0]).to_i
+  end
+
+  # Ensures that the metric string starts with "/" so the metric_id is
+  # constructer correctly
+  def prependSlashInMetric
+    if @metric != nil and @metric != ""
+      if @metric[0] != "/"
+        @metric = "/" + @metric
+      end
+    end
+    if @regexp != nil and @regexp != ""
+      if @regexp[0] != "/"
+        @regexp = "/" + @regexp
+      end
+    end
+  end
+
+  # Concatenates hostname and metric to get the metric id to pass down to
+  # the collectd GETVAL
+  #
+  # Returns the fully constructed metric id
+  def buildMetricId(socket)
+    socket.readline
+    hostname = socket.readline.strip.split(" ")[1].strip.split("/")[0]
+    if @is_regexp
+      return hostname + @regexp
+    else
+      return hostname + @metric
+    end
+  end
+
+  # Reads the results of the GETVAL from the socket, and builds a map
+  # with all the values returned for the given metric id
+  #
+  # Returns a key value map with the values list
+  def buildValueHash(socket)
+    line = socket.readline
+    if line == "ERROR: Server error: No such value."
+      return nil
+    end
+    num_lines = self.getNumResultsInSocket(line)
+    values = Hash.new
+    for i in 1..num_lines
+      rawline = socket.readline
+      line = rawline.to_s.split("=")
+      values[:"#{line[0]}"] = "%f" % line[1].to_f
+    end
+    return values
+  end
+
+  def getMetricId
+    @socket.write("LISTVAL\n")
+    metric_id = buildMetricId(@socket)
+    @socket.close
+    @socket.open
+    return metric_id
+  end
+
+  def getMetric(metric_id)
+    query = "GETVAL #{metric_id}\n"
+    @socket.write(query)
+    return self.buildValueHash(@socket)
+  end
+
+  def escapeMetricRegexp(metric_regexp)
+    return metric_regexp.to_s.gsub("/", "\\/").gsub("*", ".*")
+  end
+
+  def findMetricMatches()
+    @socket.write("LISTVAL\n")
+    rawline = @socket.readline
+    num_lines = self.getNumResultsInSocket(rawline)
+    metrics = Array.new
+    metric_id_regex = self.escapeMetricRegexp(@regexp)
+    metric_id_regex = ".*?#{metric_id_regex}"
+    for i in 1..num_lines
+      metric = @socket.readline.strip.split(" ")[1]
+      if metric.match(metric_id_regex)
+        metrics.push(metric)
+      end
+    end
+    @socket.close
+    @socket.open
+    return metrics
+  end
+
+  def getMaxMetric(metric_ids)
+    all_metrics = Array.new
+    values = nil
+    highest_metric = ""
+    for metric_id in metric_ids
+      new_values = self.getMetric(metric_id)
+      if values == nil
+        highest_metric = metric_id
+        values = new_values
+      elsif new_values[:"#{@data_name}"] > values[:"#{@data_name}"]
+        highest_metric = metric_id
+        values = new_values
+      end
+    end
+    return highest_metric, values
+  end
+
+  # Runs the sensu check, sending the calling sensu with either critical,
+  # warning or ok.
+  #
+  # XXX use exceptions in case of error instead of generating a critical and
+  # just returning
+  def run_check
+    begin
+      @socket.open
+    rescue => e
+      self.critical "Tried to access UNIX domain socket (#{@socket.socket_path}) but failed: #{e}"
+      return
+    end
+
+    begin
+      values = nil
+      metric_id = ""
+      # If we are querying an specific metric...
+      if not @is_regexp
+        # Read a metric
+        metric_id = self.getMetricId
+        # If the metric hasn't been found, error
+        if metric_id == nil
+          # Should never happen. We may end up in the rescue if we have any trouble
+          # with the socket, and that would be the only case where the metric could
+          # be null.
+          self.critical "Failed to build the metric id for #{@metric}"
+          return
+        end
+        values = self.getMetric(metric_id)
+        # If we are matching a regular expression:w
+      else
+        metrics_ids = self.findMetricMatches
+        metric_id, values = getMaxMetric(metrics_ids)
+      end
+      @socket.close
+      if values == nil
+        self.critical "The metric #{@metric} does not exist in this host."
+        return
+      end
+    rescue => e
+      self.critical "An error occured while trying to use the socket (#{@socket.socket_path}) : #{e}"
+      return
+    end
+    # Check critical threshold
+    current_value = values[:"#{@data_name}"]
+    if current_value == nil or current_value == ""
+      self.critical "Metric value #{@data_name} not found in the list"
+      return
+    end
+    current_value = current_value.to_f
+    if current_value.to_f > @critical
+      self.critical "#{metric_id}[#{@data_name}] = #{'%.2f' % current_value} is over the critical limit (#{'%.2f' % @critical})"
+      return
+    end
+    if current_value > @warning
+      self.warning "#{metric_id}[#{@data_name}] = #{'%.2f' % current_value} is over the warning limit (#{'%.2f' % @warning})"
+      return
+    end
+    if @is_regexp
+      self.ok "Everything matching #{@regexp} is within threshold"
+    else
+      self.ok "#{metric_id} is within threshold"
+    end
+  end
+
+  # Main function. It will validate the class attribute, ensure they have
+  # the correct format, and run the check with a timeout.
+  def run
+    # First, validate that the arguments passed to the handler are valid.
+    # If the are not, print an error and exit
+    is_valid, error_message = self.validateArguments
+    if !is_valid
+      puts "ERROR: #{error_message}"
+      self.warning("Wrong check: #{error_message}")
+      return
+    end
+    # Ensure correct data types and format
+    self.formatArguments
+    # Run the check with a timeout
+    begin
+      Timeout::timeout(@timeout.to_i) do
+        self.run_check
+      end
+    rescue => e
+      @socket.close
+      @cli_handler.critical "#{@metric} timed out"
+    end
+  end
+end
+
+# Sensu check. The only thing it does is initialize the socket,
+# parses the command lines arguments and instantiates the component,
+# that will do the actual run()
+class CheckCollectdSocket < Sensu::Plugin::Check::CLI
+  option :socket,
+         description: 'Supervisor UNIX domain socket (optional)',
+         short: '-s SOCKET',
+         long: '--socket SOCKET',
+         default: '/var/run/collectd-unixsock'
+
+  option :critical,
+         description: 'Value over wich the metric generate a critical alert',
+         short: '-c <critical threshold>',
+         long: '--crtical <critical threshold>'
+
+  option :warning,
+         description: 'Value over wich the metric generate a warning alert',
+         short: '-w <warning threshold>',
+         long: '--warning <warning threshold>'
+
+  option :metric,
+         description: 'Metric we want to evaluate, for example, \"processes-carbon-clickhouse/ps_count\"',
+         short: '-m <metric id>',
+         long: '--metric <metric id>',
+         default: nil
+
+  option :data_name,
+         description: 'When expect a list of values in that metric, data name must be given. Default is \"value\"',
+         short: '-d <data name>',
+         long: '--data_name <data name>',
+         default: 'value'
+
+  option :timeout,
+         description: 'Socket timeout connection',
+         short: '-t <seconds>',
+         long: '--timeout <seconds>',
+         default: 20
+
+  option :regexp,
+         description: 'Regular expresion to match serveral metrics ids. Cannot be used with the \"metric\" option',
+         short: '-r <regular expression for the metric id>',
+         long: '--regexp <regular expression for the metric id>',
+         default: nil
+
+  option :help,
+         description: 'Show help',
+         short: '-h',
+         long: '--help'
+
+  def run
+    if config[:help]
+      puts opt_parser
+      exit
+    end
+    socket = SocketWrapper.new(config[:socket])
+    component = CheckCollectdComponent.new(socket,
+                                           config[:critical],
+                                           config[:warning],
+                                           config[:metric],
+                                           config[:regexp],
+                                           config[:data_name],
+                                           config[:timeout],
+                                           self)
+    begin
+      component.run
+    rescue => e
+      critical "Unexpected exception when trying to read #{config[:socket]} (#{e})"
+    end
+  end
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sensu/plugin/collectd"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/sensu-plugin-collectd/version.rb

@@ -0,0 +1,11 @@
+module Sensu
+  module Plugin
+    module Collectd
+      MAJOR = 0
+      MINOR = 1
+      PATCH = 1
+
+      VER_STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+    end
+  end
+end

data/lib/sensu-plugin-collectd.rb

@@ -0,0 +1 @@
+require 'sensu-plugin-collectd/version'

data/sensu-plugin-collectd.gemspec

@@ -0,0 +1,29 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "sensu-plugin-collectd/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "sensu-plugin-collectd"
+  spec.version       = Sensu::Plugin::Collectd::VER_STRING
+  spec.authors       = ["Pilar Gomez"]
+  spec.email         = ["mp.gomezmoya@gmail.com"]
+
+  spec.summary       = 'Sensu plugin to pull metrics from the collectd socket'
+  spec.homepage      = "https://github.com/mpgomez/sensu-plugin-collectd"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "sensu-plugin", "~> 1.2"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.4"
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: sensu-plugin-collectd
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Pilar Gomez
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sensu-plugin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: 
+email:
+- mp.gomezmoya@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- bin/check-collectd-socket-metric.rb
+- bin/console
+- bin/setup
+- lib/sensu-plugin-collectd.rb
+- lib/sensu-plugin-collectd/version.rb
+- sensu-plugin-collectd.gemspec
+homepage: https://github.com/mpgomez/sensu-plugin-collectd
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14.1
+signing_key: 
+specification_version: 4
+summary: Sensu plugin to pull metrics from the collectd socket
+test_files: []