zabbix_sender_api 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 60cdb023473d8f310e562c2130af36a7200ef5edddf30f6783df1111a15cb2f3
+  data.tar.gz: d20950ef1e873d771bf1ccd7fab94f428e764cd33d5d35e5e7bf1a872ca2456e
+SHA512:
+  metadata.gz: ebd2c6648e9c4ab34dc1c982928b7c83f3bf998514c475d9f166c76b03a8f4cccd24471d16111c0abe72e6e86ff3d3baa0f7f71ec4843e11fb7a951aa566bd86
+  data.tar.gz: ff0383428a37b30a048b6e2c5fecab943368462a2922a6ea434635657c1f762ed976bb36e8cf5b894fdaa4931abc86bc5061295977c2100d4825b8f370ef974d

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in zabbix_sender_api.gemspec
+gemspec
+
+gem "rake"
+gem "pry"
+gem "pry-byebug"

data/Gemfile.lock

@@ -0,0 +1,30 @@
+PATH
+  remote: .
+  specs:
+    zabbix_sender_api (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (11.1.3)
+    coderay (1.1.3)
+    method_source (1.0.0)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.9.0)
+      byebug (~> 11.0)
+      pry (~> 0.13.0)
+    rake (12.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pry
+  pry-byebug
+  rake
+  zabbix_sender_api!
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Dave Parker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,118 @@
+# zabbix_sender_api
+
+This gem describes an api that takes some of the drudgery out of the task of putting together bulk data for the zabbix_sender utility.
+
+zabbix_sender is a command line utility for sending monitoring data to Zabbix server or proxy. On the Zabbix server an item of type Zabbix trapper should be created with corresponding key.
+
+ * [Zabbix sender manpage](https://www.zabbix.com/documentation/4.0/manpages/zabbix_sender)
+ * [Zabbix sender CLI help](zabbix-sender-help.md)
+
+
+zabbix_sender_api's function is to generate data to send to a zabbix_sender instance via stdin where zabbix_sender was invoked with these options:
+
+```
+  -i --input-file input-file   Load values from input file. Specify - for
+                             standard input. Each line of file contains
+                             whitespace delimited: <host> <key> <value>.
+                             Specify - in <host> to use hostname from
+                             configuration file or --host argument
+                             
+  -T --with-timestamps       Each line of file contains whitespace delimited:
+                             <host> <key> <timestamp> <value>. This can be used
+                             with --input-file option. Timestamp should be
+                             specified in Unix timestamp format
+```
+
+It is analogous to:
+
+ \<program that generates sender input\> | zabbix-sender -z \<zabbix-server-or-proxy-ip\> -T -i -
+ 
+(You can use this api to just generate output that you then pipe to zabbix_sender yourself if you prefer)
+ 
+
+## Installation
+
+    $ gem install zabbix_sender_api
+
+## Usage
+
+### Synopsis
+```ruby
+#!/usr/bin/env ruby
+require 'zabbix_sender_api'
+
+sender = Zabbix::Sender.new
+
+rawdata = { :myFirstKey => 0, :mySecondKey => 100 }
+
+data = Zabbix::Batch.new
+
+rawdata.each_pair {|key,value|
+  data.addItemData(key: key,value: value)
+}
+
+sender.sendBatchAtomic(data)
+```
+
+The above will execute zabbix_sender for you and send data into it as described above.
+
+Alternatively you can just
+
+```ruby
+puts data.to_senderinput
+```
+... and do whatever you want w/ the stdout
+
+
+To do low level discovery:
+
+```ruby
+disco = Zabbix::Discovery.new(key: 'discoveryRuleKey')
+
+disco.add_entity(:SOMEUSEFULVALUE => 'aValue', :ANOTHERONE => 'somethingElse')
+
+data.addDiscovery(disco)
+
+```
+
+### Under the hood
+
+The zabbix-sender cli utility provides a number of methods by which to insert data into zabbix. 
+
+ * zabbix-sender ... -s zabbixHostName -k keyName -o value (one k-v pair at a time)
+ * zabbix-sender ... -i - (series of kv pairs from stdin using zabbix-sender start time as timestamp)
+ * zabbix-sender ... -T -i - (series of kv pairs with their own embedded timestamps from stdin)
+
+In the latter two cases, the zabbix host name (the name of the host that zabbix is monitoring) is embedded
+in the stdin data.
+
+In all cases it is presumed that the zabbix server or proxy to which data should be sent is specified.  This can
+be done either by specifying it explicitly with the -z switch, or indirectly by pointing it to a zabbix sender configuration
+file with the -c switch.  If you let zabbix_sender_api handle executing zabbix_sender, the target will be specified on the
+command line via the -z switch.
+
+
+zabbix_sender_api utilizes the -T -i - form, so the generated data lines look like this:
+
+```
+"theHostBeingMonitored" myFirstKey 1551719379 0
+"theHostBeingMonitored" mySecondKey 1551719379 100
+```
+
+The above lines will send data to two items associated with the host theHostBeingMonitored: myFirstKey gets the value 0, and mySecondKey gets the value 100.  In both cases the
+time stamp is identical but it need not be (see the exe/example.rb for specifics).
+
+
+Low level discovery (LLD) is also possible with zabbix-sender; the format of the stdin data is not so pretty but zabbix_sender_api handles all that:
+
+```
+"theHostBeingMonitored" discoveryRuleKey 1551719797 {"data":[{"{#SOMEUSEFULVALUE}":"aValue","{#ANOTHERONE}":"somethingElse"}]}
+```
+The above line sends an LLD discovery structure (formatted as json) to the [discovery rule](https://www.zabbix.com/documentation/4.0/manual/discovery/low_level_discovery#discovery_rule) whose key is discoveryRuleKey.  It describes one entity by passing the macro values
+#SOMEUSEFULVALUE and #ANOTHERONE to the discovery rule.  These '[lld macros](https://www.zabbix.com/documentation/4.0/manual/config/macros/lld_macros)' are available for use in item,trigger, and graph prototypes.
+
+
+If you wished to use the above lld to actually do some discovery, you'd set things up in zabbix roughly like this:
+
+![Discovery rule configuration](images/Spectacle.Z29721.png)
+![Item prototype configuration](images/Spectacle.l29721.png )

data/Rakefile

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

data/bin/console

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "zabbix_sender_api"
+
+# 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
+

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/exe/example.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+require 'zabbix_sender_api'
+
+sender = Zabbix::Sender::Pipe.new
+
+rawdata = { :myFirstKey => 0, :mySecondKey => 100 }
+
+data = Zabbix::Sender::Batch.new
+
+rawdata.each_pair {|key,value|
+  data.addItemData(key: key,value: value)
+}
+
+disco = Zabbix::Sender::Discovery.new(key: 'discoveryRuleKey')
+
+disco.add_entity(:SOMEUSEFULVALUE => 'aValue', :ANOTHERONE => 'somethingElse')
+
+data.addDiscovery(disco)
+
+puts data.to_senderline
+
+sender.sendBatchAtomic(data)

data/lib/zabbix_sender_api.rb

@@ -0,0 +1,8 @@
+require "zabbix_sender_api/version"
+require "zabbix_sender_api/api"
+require "json"
+
+module ZabbixSenderApi
+  class Error < StandardError; end
+  Zabbix::AgentConfiguration.initialize
+end

data/lib/zabbix_sender_api/api.rb

@@ -0,0 +1,273 @@
+module Zabbix
+require 'socket'
+require 'json'
+
+##
+# AgentConfiguration holds data that's scraped from a zabbix_agentd config file.  It's 
+# initialized when the gem is required.  If it finds configuration you can
+# access it with class methods.  This is not meant to be instantiated.
+
+class AgentConfiguration
+  def self.initialize 
+    @agentConfPaths = [
+            '/etc/zabbix/zabbix_agentd.conf',
+            '/usr/local/etc/zabbix/zabbix_agentd.conf',
+            '/opt/zabbix/etc/zabbix_agentd.conf',
+            '/opt/zabbix/conf/zabbix_agentd.conf'
+    ]
+
+    @proxy = nil
+    @hostname = nil
+
+    @agentConfPaths.each { |path|
+            if File.exist?(path)
+                    File.new(path).each_line { |line|
+                            if not @proxy
+                                    match = /^Server=?(.*)/.match(line)
+                                    if match
+                                            @proxy = match[1].strip.split(',').pop
+                                    end
+                            end
+                            if not @hostname
+                                    match = /^Hostname=?(.*)/.match(line)
+                                    if match
+                                            @hostname = match[1].strip
+                                    end
+                            end
+                            break if @proxy and @hostname
+                    }
+            end
+            break if @proxy and @host
+    }
+    if not @host
+      @host = Socket.gethostname
+    end
+  end
+
+  ##
+  # Returns the value of the Server= assignment in zabbix_agentd.conf (if any)
+  #
+  def self.zabbixProxy
+    @proxy
+  end
+
+  ##
+  # Returns the value of the Hostname= asignment in zabbix_agentd.conf (if any)
+  #
+  def self.zabbixHostname
+    @hostname
+  end
+end
+
+module Sender
+
+##
+# Pipe instances encapsulate communication to a running instance of zabbix_sender
+# via a pipe to STDIN.  If you want your program to send data itself (as opposed
+# to say printing stdin lines that you can then pipe to zabbix_sender yourself),
+# you'll want to make an instance of this
+#
+class Pipe
+  ##
+  # pipe file handle object
+  attr_reader :pipe
+  ##
+  # target host (server or proxy) name or ip
+  attr_reader :targetHost
+  ##
+  # path to the zabbix_sender executable
+  attr_reader :exePath
+
+
+  ##
+  # Initialize a new Sender object.  Both proxy: and path: are optional.
+  #
+  # An attempt is made to provide sane default values.  If you have a zabbix_agentd.conf
+  # file in one of the usual places and zabbix_sender is on your path, it'll probably 
+  # just work
+  #
+  def initialize(proxy: Zabbix::AgentConfiguration.zabbixProxy, path: 'zabbix_sender')
+    @targetHost = proxy
+    @exePath = path
+    @pipe = nil
+  end
+
+  ##
+  # Opens a pipe to the zabbix_sender command with appropriate options specified.
+  # If the pipe is already opened when this command is called, it is first closed
+  # via a call to flush
+  def open
+    self.flush
+    @pipe = IO.popen(%Q(#{@exePath} -z #{@targetHost} -vv -T -i-),'w')
+  end
+
+  ##
+  # Closes the zabbix_sender pipe if it's open
+  def flush
+    if @pipe and not @pipe.closed?
+      @pipe.close
+    end
+  end
+
+  ##
+  # Send a Batch instance to zabbix (via zabbix_sender).  This assumes that
+  # the pipe is already open.
+  def sendBatch(aBatch)
+    # Assumes that the pipe is open
+    @pipe.puts(aBatch.to_senderline)
+  end
+
+  ##
+  # Send a Batch instance to zabbix (via zabbix_sender).  This opens the pipe,
+  # writes the data to the pipe, and closes the pipe all in one go.
+  def sendBatchAtomic(aBatch)
+    self.open
+    self.sendBatch(aBatch)
+    self.flush
+  end
+
+end
+
+##
+# ItemData instances hold the k-v pair of a value and its timestamp
+# along with the hostname to which the data belongs.  It handles
+# formatting that data appropriately as input to zabbix_sender
+class ItemData
+  ##
+  # The item key that'll get the new value
+  attr_accessor:key
+  ##
+  # The value that the item will get
+  attr_accessor :value
+  ##
+  # The name of the zabbix host that owns the item key
+  attr_accessor :hostname
+  ##
+  # The timestamp for this datapoint
+  attr_accessor :timestamp
+
+  ##
+  # All values must be provided. 
+  def initialize(key: nil,value: nil, timestamp:  nil, hostname: nil)
+    @key = key
+    @value = value
+    @timestamp = timestamp
+    @hostname = hostname
+  end
+
+  ##
+  # Render the ItemData instance as a line of text that can be piped into zabbix_sender
+  def to_senderline
+    if @timestamp.to_i == 0
+      puts %Q("#{@hostname}" #{@key} #{@timestamp.to_i} #{@value}\n)
+      abort("Attempt was made to render a timestamp of zero.  You DO NOT want this - it can kill db performance. Fix it.")
+    end
+    return %Q("#{@hostname}" #{@key} #{@timestamp.to_i} #{@value}\n)
+  end
+end
+
+##
+# Discovery instances are a special type of ItemData that you will typically
+# create and hang on to as you accumulate (discover) related entities. You
+# then pass the discover instance into a Batch via addDiscovery(), which 
+# includes it in the batch of data just like an ordinary ItemData instance.
+class Discovery < ItemData
+  ##
+  # The only required parameter is key:, which is the discovery rule key.
+  #
+  def initialize(key: nil,value: nil, timestamp:  nil, hostname: nil)
+    super
+    @entities = Array.new
+  end
+  ##
+  # This is how you pass data to zabbix that you use to construct items from item templates.  Pass in
+  # as many key-value pairs as you need.  You'll reference these in the item prototype like {#MYKEY}
+  #
+  # Note that the keys (which you can pass as symbols if you want) are forced to uppercase.  This is
+  # here because the author once spent way too much time trying to figure out why discovery wasn't
+  # working right one day.  All caps seems to fix the issue.
+  #
+  def add_entity(aHash)
+    # just send in key value pairs - these will be the variables you can use in the discovery item prototypes
+    zabbified = Hash.new
+    aHash.each_pair { |key,value|
+      zabbified[%Q({##{key.to_s.upcase}})] = value
+    }
+    @entities.push(zabbified)
+  end
+  ##
+  # Render this discovery instance as a zabbix_sender line.
+  #
+  def to_senderline
+    disco = { 'data'=>Array.new }
+    disco['data'] = @entities
+    @value = disco.to_json
+    super
+  end
+end
+
+##
+# Batch instances hold all the data and discovery that you collect as your program
+# does its thing with source data. Once you've done all your data collection, you can:
+#
+# * Send the batch instance to an instance of Pipe to have it transmitted to zabbix
+# * puts mybatch.to_senderline to output the zabbix_sender input text 
+# * Use it to help feed data into zabbix by whatever other mechanism you might be
+#   using, e.g. a ruby implementation of the zabbix sender protocol
+#
+class Batch
+  ##
+  # This is an array of all the ItemData and Discovery instances that have been added
+  # to this discovery since instantiation.
+  #
+  attr_reader :data
+
+  ##
+  # Both parameters are optional - reasonable defaults are provided.
+  #
+  # Bear in mind that the hostname and timestamp values you provide here will be applied
+  # to all the ItemData and Discovery objects you add via the addItemData() and 
+  # addDiscovery() methods by default (unless you override them when you add them)
+  def initialize(timestamp: Time.now, hostname: Zabbix::AgentConfiguration.zabbixHostname)
+    @time = timestamp
+    @hostname = hostname
+    @data = Array.new
+  end
+  ##
+  # Create a new instance of ItemData and add that instance to the list of data that this
+  # batch contains. You must provide a key and a value.  You *can* provide a timestamp and
+  # a hostname.  If you do not provide a timestamp or hostname, they will be given the
+  # timestamp and hostname associated with the instance of Batch that you're working with
+  # 
+  def addItemData(key: nil,value: nil,timestamp: @time, hostname: @hostname)
+    @data.push(ItemData.new(key: key,value: value,timestamp: timestamp,hostname: hostname))
+  end
+
+  ##
+  # Add a discovery object to this batch of data.  The object will be added to the 
+  # top of the item list.
+  #
+  # If you did not specifically provide a hostname or a timestamp when you
+  # instantiated the Discovery, they'll given the ones provided when this instance
+  # of Batch was constructed.
+  #
+  def addDiscovery(aDiscovery)
+    # It doesn't matter right now really as zabbix has to digest the disco
+    # and won't do it before it tries to process the data, but it makes logical
+    # sense to put discos first.
+    aDiscovery.timestamp = @time if not aDiscovery.timestamp
+    aDiscovery.hostname = @hostname if not aDiscovery.hostname
+    @data.unshift(aDiscovery)
+  end
+
+  ##
+  # Render this batch of data as a sequence of lines of text appropriate
+  # for sending into zabbix_sender
+  #
+  def to_senderline
+    @data.collect {|line| line.to_senderline}.join
+  end
+end
+
+end # module Sender
+end # module Zabbix

data/lib/zabbix_sender_api/version.rb

@@ -0,0 +1,3 @@
+module ZabbixSenderApi
+  VERSION = "1.0.0"
+end

data/zabbix-sender-help.md

@@ -0,0 +1,73 @@
+```
+root@zabbix-server:~# /opt/zabbix-server/bin/zabbix_sender -h
+usage:
+  zabbix_sender [-v] -z server [-p port] [-I IP-address] -s host -k key
+                -o value
+  zabbix_sender [-v] -z server [-p port] [-I IP-address] [-s host] [-T] [-r]
+                -i input-file
+  zabbix_sender [-v] -c config-file [-z server] [-p port] [-I IP-address]
+                [-s host] -k key -o value
+  zabbix_sender [-v] -c config-file [-z server] [-p port] [-I IP-address]
+                [-s host] [-T] [-r] -i input-file
+  zabbix_sender -h
+  zabbix_sender -V
+
+Utility for sending monitoring data to Zabbix server or proxy.
+
+General options:
+  -c --config config-file    Path to Zabbix agentd configuration file
+
+  -z --zabbix-server server  Hostname or IP address of Zabbix server or proxy
+                             to send data to. When used together with --config,
+                             overrides the first entry of "ServerActive"
+                             parameter specified in agentd configuration file
+
+  -p --port port             Specify port number of trapper process of Zabbix
+                             server or proxy. When used together with --config,
+                             overrides the port of the first entry of
+                             "ServerActive" parameter specified in agentd
+                             configuration file (default: 10051)
+
+  -I --source-address IP-address   Specify source IP address. When used
+                             together with --config, overrides "SourceIP"
+                             parameter specified in agentd configuration file
+
+  -s --host host             Specify host name the item belongs to (as
+                             registered in Zabbix frontend). Host IP address
+                             and DNS name will not work. When used together
+                             with --config, overrides "Hostname" parameter
+                             specified in agentd configuration file
+
+  -k --key key               Specify item key
+  -o --value value           Specify item value
+
+  -i --input-file input-file   Load values from input file. Specify - for
+                             standard input. Each line of file contains
+                             whitespace delimited: <host> <key> <value>.
+                             Specify - in <host> to use hostname from
+                             configuration file or --host argument
+
+  -T --with-timestamps       Each line of file contains whitespace delimited:
+                             <host> <key> <timestamp> <value>. This can be used
+                             with --input-file option. Timestamp should be
+                             specified in Unix timestamp format
+
+  -r --real-time             Send metrics one by one as soon as they are
+                             received. This can be used when reading from
+                             standard input
+
+  -v --verbose               Verbose mode, -vv for more details
+
+  -h --help                  Display this help message
+  -V --version               Display version number
+
+TLS connection options:
+  Not available. This Zabbix sender was compiled without TLS support
+
+Example(s):
+  zabbix_sender -z 127.0.0.1 -s "Linux DB3" -k db.connections -o 43
+
+Report bugs to: <https://support.zabbix.com>
+Zabbix home page: <http://www.zabbix.com>
+Documentation: <https://www.zabbix.com/documentation>
+```

data/zabbix_sender_api.gemspec

@@ -0,0 +1,28 @@
+require_relative 'lib/zabbix_sender_api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "zabbix_sender_api"
+  spec.version       = ZabbixSenderApi::VERSION
+  spec.authors       = ["Dave Parker"]
+  spec.email         = ["daveparker01@gmail.com"]
+
+  spec.summary       = %q{Ruby frontend to the zabbix_sender command line tool}
+  spec.description   = %q{This gem describes an api to the zabbix sender facility. It saves tons of hassle when you're cranking out custom polling logic}
+  spec.homepage      = "https://gitlab.com/svdasein/zabbix_sender_api"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://gitlab.com/svdasein/zabbix_sender_api"
+
+  # 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"]
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: zabbix_sender_api
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Dave Parker
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-08-02 00:00:00.000000000 Z
+dependencies: []
+description: This gem describes an api to the zabbix sender facility. It saves tons
+  of hassle when you're cranking out custom polling logic
+email:
+- daveparker01@gmail.com
+executables:
+- example.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/example.rb
+- images/.gitkeep
+- images/Spectacle.Z29721.png
+- images/Spectacle.l29721.png
+- lib/zabbix_sender_api.rb
+- lib/zabbix_sender_api/api.rb
+- lib/zabbix_sender_api/version.rb
+- zabbix-sender-help.md
+- zabbix_sender_api.gemspec
+homepage: https://gitlab.com/svdasein/zabbix_sender_api
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://gitlab.com/svdasein/zabbix_sender_api
+  source_code_uri: https://gitlab.com/svdasein/zabbix_sender_api
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Ruby frontend to the zabbix_sender command line tool
+test_files: []