logstash-filter-phpipam 0.7.5 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2d2e780de960d171b81b544234dc8f752577cf5f28636da7b26d19c9db98d8c
-  data.tar.gz: a9ed65dd68109a2df0f8225e7dfda292ddae1ca32945fa85a115b720e9f6b34e
+  metadata.gz: 4874331ae90441dff667b067ac4609b7811a40a2bf65cb7e0ac19ba8950ae306
+  data.tar.gz: 88be65d72fb3a240f7e8a82ae72be5b9977f106b7a39451ca320bbce0900d48b
 SHA512:
-  metadata.gz: f69665cbe6a42af223f0c692bf32174e68ca057ec27ce3d3faaa10eaee61d6d71dea92c5ff695de47f0903829bd7326418c877f5369ab1ab17610938fed4cc75
-  data.tar.gz: f82c9a5559499778bc6ce3f523ce9decd90fa46ed65dce2c2188392c29b05e094bd23a4e983d6c39aab3c35f9889c640f32836702cd0e70476851b0fde9204fb
+  metadata.gz: fa801fdd8549deb74f13b360ba66b38667f20bed34faab5b936a330f097b4fdc2d5e4ca634104cee7df9735eae7c6cbfcb27a0610cc5a7ef26869e247974aa1d
+  data.tar.gz: e41ca0a859cf078749e204a9227f0aef0c77d55ceff9242be42a9ae7a6e3ae9119bb9f33248a26869a5c36260c183b46d209244854ce11ccec6d0bb098fd4181

data/README.md

@@ -2,23 +2,40 @@
 A Logstash filter that looks up an IP-address, and returns results from phpIPAM
 
 ## Installation
+### Prerequisites
+[Redis](https://redis.io/) is required for this plugin to work.
+
+You can install it using most your distributions package manager.
+
+#### Ubuntu example
+You can install it with apt:
+```bash
+sudo apt install redis
+```
+
+
+### Plugin
 This plugin can be installed using the `logstash-plugin` command in $LOGSTASH_HOME:
 ```bash
 ${LOGSTASH_HOME:-/usr/share/logstash}/bin/logstash-plugin install logstash-filter-phpipam
 ```
 
 ## Configuration options
-| Option     | Type    | Default                           | Comment                                                                         |
-| ---------- | ------- | --------------------------------- | ------------------------------------------------------------------------------- |
-| host       | string  |                                   | What host to connect to with protocol and optional port(e.g. https://fqdn:3000) |
-| app_id     | string  |                                   | See below                                                                       |
-| username   | string  |                                   | Username to use for the connection                                              |
-| password   | string  |                                   | Password to use for the connection                                              |
-| auth       | boolean | true                              | Whether to use authentication or not                                            |
-| cache      | boolean | true                              | Whether to use a cache file or not                                              |
-| cache_path | string  | /tmp/logstash-filter-phpipam.json | Where to place the cache file. tmpfs is recommended                             |
-| source     | string  |                                   | Which field the IP-address is in                                                |
-| target     | string  | phpipam                           | Where to place the phpIPAM data in                                              |
+| Option          | Type    | Default       | Comment                                                                          |
+| --------------- | ------- | ------------- | -------------------------------------------------------------------------------- |
+| host            | string  |               | What host to connect to with protocol and optional port (e.g. https://fqdn:3000) |
+| app_id          | string  |               | See below                                                                        |
+| username        | string  |               | Username to use for the connection                                               |
+| password        | string  |               | Password to use for the connection                                               |
+| auth            | boolean | true          | Whether to use authentication or not                                             |
+| cache_ip        | integer | 0             | ID of the redis database for IP-addresses                                        |
+| cache_subnet    | integer | 1             | ID of the redis database for subnets                                             |
+| cache_vlan      | integer | 2             | ID of the redis database for vlans                                               |
+| cache_device    | integer | 3             | ID of the redis database for devices                                             |
+| cache_location  | integer | 4             | ID of the redis database for locations                                           |
+| cache_freshness | integer | 86400 (1 day) | How long, in seconds, a value should be cached before it's expired               |
+| source          | string  |               | Which field the IP-address is in                                                 |
+| target          | string  | phpipam       | Where to place the phpIPAM data in                                               |
 
 `app_id` can be found in phpIPAM: Administration -> API \
 It's recommended to use SSL when accessing the app_id in phpIPAM.
@@ -33,7 +50,7 @@ To use the latitude and longtitude in Kibana Maps, you either need to:
 For option 2, if you use the default target of `phpipam`, you can do something like this, after the phpipam filter:
 ```
 mutate {
-  copy => {
+  rename => {
     "[phpipam][location][location]" => "[geo][location]"
   }
 }

data/lib/logstash/filters/phpipam.rb

@@ -7,6 +7,7 @@ require 'json'
 require 'net/http'
 require 'openssl'
 require 'uri'
+require 'redis'
 
 # A Logstash filter that looks up an IP-address, and returns results from phpIPAM
 class LogStash::Filters::Phpipam < LogStash::Filters::Base
@@ -25,11 +26,15 @@ class LogStash::Filters::Phpipam < LogStash::Filters::Base
   # Whether to use authentication or not
   config :auth, validate: :boolean, default: true
 
-  # Whether to use caching or not
-  config :cache, validate: :boolean, default: true
+  # Cache fressness
+  config :cache_freshness, validate: :number, default: 86_400
 
-  # Which file to use as cache storage. Should be placed on a tmpfs volume for maximum performance
-  config :cache_path, validate: :string, default: '/tmp/logstash-filter-phpipam.json'
+  # All the caching stores
+  config :cache_ip, validate: :number, default: 0
+  config :cache_subnet, validate: :number, default: 1
+  config :cache_vlan, validate: :number, default: 2
+  config :cache_device, validate: :number, default: 3
+  config :cache_location, validate: :number, default: 4
 
   # IP-address field to look up
   config :source, validate: :string, required: true
@@ -44,7 +49,25 @@ class LogStash::Filters::Phpipam < LogStash::Filters::Base
     # Get a session token
     @token = send_rest_request('POST', "api/#{@app_id}/user/")['token'] if @auth
 
+    # Normalize target
     @target = normalize_target(@target)
+
+    @cache_freshness = @cache_freshness.to_i
+
+    @cs_ip       = Redis.new(db: @cache_ip, id: 'logstash-filter-phpipam')
+    @cs_subnet   = Redis.new(db: @cache_subnet, id: 'logstash-filter-phpipam')
+    @cs_vlan     = Redis.new(db: @cache_vlan, id: 'logstash-filter-phpipam')
+    @cs_device   = Redis.new(db: @cache_device, id: 'logstash-filter-phpipam')
+    @cs_location = Redis.new(db: @cache_location, id: 'logstash-filter-phpipam')
+  end
+
+  def close
+    # Persist the database to disk, when the pipeline ends
+    @cs_ip.bgsave
+    @cs_subnet.bgsave
+    @cs_vlan.bgsave
+    @cs_device.bgsave
+    @cs_location.bgsave
   end
 
   def filter(event)
@@ -54,11 +77,14 @@ class LogStash::Filters::Phpipam < LogStash::Filters::Base
 
     return unless valid_ip?(ip, event)
 
-    # Get data from cache or phpIPAM if not in cache
-    event_data = search_cache(ip) if @cache
-    event_data = phpipam_data(ip, event) unless event_data.is_a?(Hash)
+    # Get the data
+    event_data = phpipam_data(ip)
 
-    return if !event_data['error'].nil? && event_data['error']
+    # Tag and return if no IP was found
+    if event_data.nil?
+      event.tag('_phpipam_ip_not_found')
+      return
+    end
 
     # Set the data to the target path
     event.set(@target, event_data)
@@ -93,10 +119,10 @@ class LogStash::Filters::Phpipam < LogStash::Filters::Base
     false
   end
 
-  # Sends a GET method REST request.
+  # Sends a GET method REST request. Returns nil if no data/an error was found
   # @param method: which HTTP method to use (POST, GET)
   # @param url_path: path to connect to
-  # @return [hash]
+  # @return [hash/nil]
   def send_rest_request(method, url_path)
     @logger.debug? && @logger.debug('Sending request', host: @host, path: url_path)
 
@@ -133,9 +159,9 @@ class LogStash::Filters::Phpipam < LogStash::Filters::Base
     # Raise an error if not a code 200 is returned
     raise LogStash::ConfigurationError, "#{rsp['code']}:#{rsp['message']}" if rsp['code'] != 200
 
-    # Return error if no data field is present, else return the data
+    # Return nil if no data field is present, else return the data
     rsp = if rsp['data'].nil?
-            { 'error' => true }
+            nil
           else
             rsp['data'].is_a?(Array) ? rsp['data'][0] : rsp['data']
           end
@@ -151,133 +177,159 @@ class LogStash::Filters::Phpipam < LogStash::Filters::Base
     value.nil? || value.empty?
   end
 
-  # Checks if the value is defined and not nil or error
-  # @param value: a value to check
-  # @return [bool]
-  def okay?(value)
-    !defined?(value).nil? && !value.nil? && value['error'].nil?
-  end
-
-  # Queries phpIPAM and formats the data
-  # @param ip: an IP-address to query
-  # @return [hash]
-  def phpipam_data(ip, event)
-    # Fetch base data needed from phpIPAM
-    ip_data = send_rest_request('GET', "api/#{@app_id}/addresses/search/#{ip}/")
-
-    # If the IP wasn't found, return and do nuthin'
-    if !ip_data['error'].nil? && ip_data['error']
-      event.tag('_phpipam_ip_not_found')
-      return { 'error' => true }
-    end
-
-    subnet_data = send_rest_request('GET', "api/#{@app_id}/subnets/#{ip_data['subnetId']}/") unless nil_or_empty?(ip_data['subnetId'])
-    vlan_data   = send_rest_request('GET', "api/#{@app_id}/vlans/#{subnet_data['vlanId']}/") unless nil_or_empty?(subnet_data['vlanId'])
-
-    device_data   = send_rest_request('GET', "api/#{@app_id}/tools/devices/#{ip_data['deviceId']}/") unless ip_data['deviceId'] == '0' || nil_or_empty?(ip_data['deviceId'])
-    location_data = send_rest_request('GET', "api/#{@app_id}/tools/locations/#{ip_data['location']}/") unless ip_data['location'] == '0' || nil_or_empty?(ip_data['location'])
-
+  # Get phpIPAM data either from cache or phpIPAM.
+  # If data was found from phpIPAM, it will cache it for future needs.
+  # If the data wasn't found in either cache or phpIPAM, nil is returned.
+  # @param ip - IP-address to lookup
+  # @return [hash/nil]
+  def phpipam_data(ip)
     # Base hash to format data in
     base = {
-      'ip' => {},
+      'ip'       => {},
+      'subnet'   => {},
+      'vlan'     => {},
+      'device'   => {},
+      'location' => {},
     }
 
-    # IP information
-    base['ip']['id']          = ip_data['id'].to_i
-    base['ip']['address']     = ip_data['ip']
-    base['ip']['description'] = ip_data['description'] unless nil_or_empty?(ip_data['description'])
-    base['ip']['hostname']    = ip_data['hostname'] unless nil_or_empty?(ip_data['hostname'])
-    base['ip']['mac']         = ip_data['mac'] unless nil_or_empty?(ip_data['mac'])
-    base['ip']['note']        = ip_data['note'] unless nil_or_empty?(ip_data['note'])
-    base['ip']['owner']       = ip_data['owner'] unless nil_or_empty?(ip_data['owner'])
-
-    # Subnet information
-    if okay?(subnet_data)
-      base['subnet']               = {}
-      base['subnet']['id']         = ip_data['subnetId'].to_i
-      base['subnet']['section_id'] = subnet_data['sectionId'].to_i
-      base['subnet']['bitmask']    = subnet_data['calculation']['Subnet bitmask'].to_i
-      base['subnet']['wildcard']   = subnet_data['calculation']['Subnet wildcard']
-      base['subnet']['netmask']    = subnet_data['calculation']['Subnet netmask']
-      base['subnet']['network']    = subnet_data['calculation']['Network']
+    # If 0 is returned, it has been cached as non-existent
+    return nil if @cs_ip.get(ip) == '0'
+
+    ## IP LOOKUP ##
+    if @cs_ip.get(ip).nil?
+      ip_data = send_rest_request('GET', "api/#{@app_id}/addresses/search/#{ip}/")
+
+      # Return and cache 0 for this IP, if it wasn't found in phpIPAM
+      if ip_data.nil?
+        @cs_ip.set(ip, '0', ex: @cache_freshness)
+        return nil
+      end
+
+      # IP information
+      base['ip']['id']          = ip_data['id'].to_i
+      base['ip']['address']     = ip_data['ip']
+      base['ip']['description'] = ip_data['description'] unless nil_or_empty?(ip_data['description'])
+      base['ip']['hostname']    = ip_data['hostname'] unless nil_or_empty?(ip_data['hostname'])
+      base['ip']['mac']         = ip_data['mac'] unless nil_or_empty?(ip_data['mac'])
+      base['ip']['note']        = ip_data['note'] unless nil_or_empty?(ip_data['note'])
+      base['ip']['owner']       = ip_data['owner'] unless nil_or_empty?(ip_data['owner'])
+
+      # Get all the ID's
+      base['ip']['subnet_id']   = ip_data['subnetId'].to_i
+      base['ip']['device_id']   = ip_data['deviceId'].to_i
+      base['ip']['location_id'] = ip_data['location'].to_i
+
+      @cs_ip.set(ip, base['ip'].to_json, ex: @cache_freshness)
+    else
+      base['ip'] = JSON.parse(@cs_ip.get(ip))
     end
 
-    # VLAN information
-    if okay?(vlan_data)
-      base['vlan']                = {}
-      base['vlan']['id']          = subnet_data['vlanId'].to_i
-      base['vlan']['domain_id']   = vlan_data['domainId'].to_i
-      base['vlan']['number']      = vlan_data['number'].to_i unless nil_or_empty?(vlan_data['number'])
-      base['vlan']['name']        = vlan_data['name'] unless nil_or_empty?(vlan_data['name'])
-      base['vlan']['description'] = vlan_data['description'] unless nil_or_empty?(vlan_data['description'])
+    ## SUBNET LOOKUP ##
+    subnet_id = base['ip']['subnet_id']
+
+    # If 0 is returned, it doesn't exist. Only lookup if a nonzero value is returned
+    if subnet_id.positive?
+      if @cs_subnet.get(subnet_id).nil?
+        subnet_data = send_rest_request('GET', "api/#{@app_id}/subnets/#{subnet_id}/")
+
+        # Subnet data
+        base['subnet']['id']         = subnet_id
+        base['subnet']['section_id'] = subnet_data['sectionId'].to_i
+        base['subnet']['bitmask']    = subnet_data['calculation']['Subnet bitmask'].to_i
+        base['subnet']['wildcard']   = subnet_data['calculation']['Subnet wildcard']
+        base['subnet']['netmask']    = subnet_data['calculation']['Subnet netmask']
+        base['subnet']['network']    = subnet_data['calculation']['Network']
+
+        # Get VLAN id and location _id
+        base['subnet']['vlan_id']     = subnet_data['vlanId'].to_i
+        base['subnet']['location_id'] = subnet_data['location'].to_i
+
+        @cs_subnet.set(subnet_id, base['subnet'].to_json, ex: @cache_freshness)
+      else
+        base['subnet'] = JSON.parse(@cs_subnet.get(subnet_id))
+      end
     end
 
-    # Device information
-    if okay?(device_data)
-      type = send_rest_request('GET', "api/#{@app_id}/tools/device_types/#{device_data['type']}/")
-
-      base['device']                = {}
-      base['device']['id']          = ip_data['deviceId'].to_i
-      base['device']['name']        = device_data['hostname'] unless nil_or_empty?(device_data['hostname'])
-      base['device']['description'] = device_data['description'] unless nil_or_empty?(device_data['description'])
-      base['device']['type']        = type['tname'] unless nil_or_empty?(type['tname'])
+    ## VLAN LOOKUP ##
+    vlan_id = base['subnet']['vlan_id']
+
+    # If 0 is returned, it doesn't exist. Only lookup if a nonzero value is returned
+    if vlan_id.positive?
+      if @cs_vlan.get(vlan_id).nil?
+        vlan_data = send_rest_request('GET', "api/#{@app_id}/vlans/#{vlan_id}/")
+
+        # VLAN data
+        base['vlan']['id']          = vlan_id
+        base['vlan']['domain_id']   = vlan_data['domainId'].to_i
+        base['vlan']['number']      = vlan_data['number'].to_i unless nil_or_empty?(vlan_data['number'])
+        base['vlan']['name']        = vlan_data['name'] unless nil_or_empty?(vlan_data['name'])
+        base['vlan']['description'] = vlan_data['description'] unless nil_or_empty?(vlan_data['description'])
+
+        @cs_vlan.set(vlan_id, base['vlan'].to_json, ex: @cache_freshness)
+      else
+        base['vlan'] = JSON.parse(@cs_vlan.get(vlan_id))
+      end
     end
 
-    # If the IP doesn't have the location directly, try to get it from the device or subnet
-    unless okay?(location_data)
-      location_data = if okay?(device_data) && device_data['location'] != '0' && !nil_or_empty?(device_data['location'])
-                        send_rest_request('GET', "api/#{@app_id}/tools/locations/#{device_data['location']}/")
-                      elsif okay?(subnet_data) && subnet_data['location'] != '0' && !nil_or_empty?(subnet_data['location'])
-                        send_rest_request('GET', "api/#{@app_id}/tools/locations/#{subnet_data['location']}/")
-                      end
-    end
+    ## DEVICE LOOKUP ##
+    device_id = base['ip']['device_id']
 
-    # Location information
-    if okay?(location_data)
-      base['location']                = {}
-      base['location']['id']          = location_data['id'].to_i
-      base['location']['address']     = location_data['address'] unless nil_or_empty?(location_data['address'])
-      base['location']['name']        = location_data['name'] unless nil_or_empty?(location_data['name'])
-      base['location']['description'] = location_data['description'] unless nil_or_empty?(location_data['description'])
-      base['location']['location']    = { 'lat' => location_data['lat'].to_f, 'lon' => location_data['long'].to_f } unless nil_or_empty?(location_data['lat'])
-    end
+    # If 0 is returned, it doesn't exist. Only lookup if a nonzero value is returned
+    if device_id.positive?
+      if @cs_device.get(device_id).nil?
+        device_data = send_rest_request('GET', "api/#{@app_id}/tools/devices/#{device_id}/")
 
-    # Cache it for future needs
-    cache_data(base) if @cache
+        # Device data
+        type = send_rest_request('GET', "api/#{@app_id}/tools/device_types/#{device_data['type']}/")
 
-    # all your base are belong to us
-    base
-  end
+        base['device']['id']          = device_id
+        base['device']['name']        = device_data['hostname'] unless nil_or_empty?(device_data['hostname'])
+        base['device']['description'] = device_data['description'] unless nil_or_empty?(device_data['description'])
+        base['device']['type']        = type['tname'] unless nil_or_empty?(type['tname'])
 
-  # Caches data (if possible)
-  # @param data: the data to cache
-  # @return [void]
-  def cache_data(data)
-    data = data.to_json
+        # Get device location
+        base['device']['location_id'] = device_data['location'].to_i
 
-    File.open(@cache_path, 'a') do |file|
-      file.write(data + "\n")
-      @logger.debug? && @logger.debug('Cached data', data: data)
-    rescue StandardError
-      @logger.debug? && @logger.debug('Cache file is not writable, skipping caching of data', data: data, cache_file: @cache_path)
-      break
+        @cs_device.set(device_id, base['device'].to_json, ex: @cache_freshness)
+      else
+        base['device'] = JSON.parse(@cs_device.get(device_id))
+      end
     end
-  end
-
-  # Seaches the cache file for the IP.
-  # Returns a hash if the IP was found, else false
-  # @param ip: The IP-address to search for
-  # @return [hash/bool]
-  def search_cache(ip)
-    @logger.debug? && @logger.debug('Searching cache...', ip: ip)
 
-    return false unless File.exist?(@cache_path)
-
-    File.foreach(@cache_path) do |line|
-      line = JSON.parse(line)
-      return line if line['ip']['address'] == ip
+    ## LOCATION LOOKUP ##
+    # Get the first positive location_id from the list
+    location_id = [base['ip']['location_id'], base['device']['location_id'], base['subnet']['location_id']].select { |num|
+      !num.nil? && num.positive?
+    }[0] || 0
+
+    # If 0 is returned, it doesn't exist. Only lookup if a nonzero value is returned
+    if location_id.positive?
+      if @cs_location.get(location_id).nil?
+        location_data = send_rest_request('GET', "api/#{@app_id}/tools/locations/#{location_id}/")
+
+        # Location  data
+        base['location']['id']          = location_id
+        base['location']['address']     = location_data['address'] unless nil_or_empty?(location_data['address'])
+        base['location']['name']        = location_data['name'] unless nil_or_empty?(location_data['name'])
+        base['location']['description'] = location_data['description'] unless nil_or_empty?(location_data['description'])
+        base['location']['location']    = { 'lat' => location_data['lat'].to_f, 'lon' => location_data['long'].to_f } unless nil_or_empty?(location_data['lat'])
+
+        @cs_location.set(location_id, base['location'].to_json, ex: @cache_freshness)
+      else
+        base['location'] = JSON.parse(@cs_location.get(location_id))
+      end
     end
 
-    false
+    # Clean-up keys that aren't needed in the final Logstash output
+    base['ip'].delete('subnet_id')
+    base['ip'].delete('device_id')
+    base['ip'].delete('location_id')
+    base['subnet'].delete('vlan_id')
+    base['subnet'].delete('location_id')
+    base['device'].delete('location_id')
+    base.delete_if { |_, val| val.empty? }
+
+    # all your base are belong to us
+    base
   end
 end

data/logstash-filter-phpipam.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name          = 'logstash-filter-phpipam'
-  s.version       = '0.7.5'
+  s.version       = '0.8.0'
   s.licenses      = ['Apache-2.0']
   s.summary       = 'A Logstash filter that returns results from phpIPAM'
   s.description   = 'A Logstash filter that looks up an IP-address, and returns results from phpIPAM'
@@ -21,5 +21,6 @@ Gem::Specification.new do |s|
 
   # Gem dependencies
   s.add_runtime_dependency 'logstash-core-plugin-api', '~> 2.0'
-  s.add_development_dependency 'logstash-devutils'
+  s.add_runtime_dependency 'redis', '~> 4.1', '>= 4.1.2'
+  s.add_development_dependency 'logstash-devutils', '~> 1.3', '>= 1.3.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-filter-phpipam
 version: !ruby/object:Gem::Version
-  version: 0.7.5
+  version: 0.8.0
 platform: ruby
 authors:
 - magnuslarsen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-16 00:00:00.000000000 Z
+date: 2019-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logstash-core-plugin-api
@@ -24,20 +24,46 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.2
 - !ruby/object:Gem::Dependency
   name: logstash-devutils
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.6
 description: A Logstash filter that looks up an IP-address, and returns results from
   phpIPAM
 email: ''
@@ -76,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: A Logstash filter that returns results from phpIPAM