logstash-filter-rest 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3831712120e49fe2fc5f76a125bf0fd36d2b3779
-  data.tar.gz: 5e66b534d403ef9e70005a703efc92dc98ee242c
+  metadata.gz: 70cf7db34fec1104a8eb742ce5633c11769a66d5
+  data.tar.gz: c265edbd76879148168331adc875befb458ec0a6
 SHA512:
-  metadata.gz: b65e31422305236f2e59e3511823e42a28c09a5ca3400aa73ab9bceaed85e05d6f60fc3ad293888de62574bd91dc64220079a43fd1f7463cd9e8e72ce6a030a3
-  data.tar.gz: f38a4d7b09b5eb816acce96bf72fe194a8899c538899014fde2a04eb63deb82fa291ed5d6bbc03c117ec8830fed18e778011d54e1e116a15e19775c521d5e333
+  metadata.gz: fac6c51358cd5cd6e9990807f03b169aeca591ea828c11f1b718b39639e99770edd534f896aa0b0ec1da8ed3e441d7807f34f8cfdf26e1403c75d73eeeaddbcd
+  data.tar.gz: 70a3d59b3d30ebc070e715f97be104c4e2161b59405b5ac488963a78d1eb8b400dd7b1d71025c8d382ca52d34d13de56401331793089a37d200c9d85872d5e86

data/README.md

@@ -1,4 +1,4 @@
-# Logstash REST Filter
+# Logstash REST Filter [![Build Status](https://travis-ci.org/gandalfb/logstash-filter-rest.svg?branch=http-keep-alive)](https://travis-ci.org/gandalfb/logstash-filter-rest)
 
 This is a filter plugin for [Logstash](https://github.com/elasticsearch/logstash).
 
@@ -27,22 +27,33 @@ $LS_HOME/bin/plugin install logstash-filter-rest-0.1.0.gem
 Add the following inside the filter section of your logstash configuration:
 
 ```sh
-rest {
-  url => "http://example.com"       # string (required, with field reference: "http://example.com?id=%{id}")
-  json => true                      # boolean (optional, default = false)
-  method => "post"                  # string (optional, default = "get")
-  sprintf => true                   # boolean (optional, default = false, set this to true if you want to use field references in url, header or params)
-  header => {                       # hash (optional)
-    "key1" => "value1"
-    "key2" => "value2"
-    "key3" => "%{somefield}"        # Please set sprintf to true if you want to use field references
+filter {
+  rest {
+    request => {
+      url => "http://example.com"       # string (required, with field reference: "http://example.com?id=%{id}" or params, if defined)
+      method => "post"                  # string (optional, default = "get")
+      headers => {                       # hash (optional)
+        "key1" => "value1"
+        "key2" => "value2"
+      }
+      auth => {
+        user => "AzureDiamond"
+        password => "hunter2"
+      }
+      params => {                       # hash (optional, available for method => "get" and "post"; if post it will be transformed into body hash and posted as json)
+        "key1" => "value1"
+        "key2" => "value2"
+        "key3" => "%{somefield}"        # Please set sprintf to true if you want to use field references
+      }
+    }
+    json => true                      # boolean (optional, default = false)
+    sprintf => true                   # boolean (optional, default = false, set this to true if you want to use field references in url, header or params)
+    target => "my_key"          # string (optional, default = "rest_response")
+    fallback => {                     # hash describing a default in case of error
+      "key1" => "value1"
+      "key2" => "value2"
+    }
   }
-  params => {                       # hash (optional, only available for method => "post")
-    "key1" => "value1"
-    "key2" => "value2"
-    "key3" => "%{somefield}"        # Please set sprintf to true if you want to use field references
-  }
-  response_key => "my_key"          # string (optional, default = "rest_response")
 }
 ```
 

data/lib/logstash/filters/rest.rb

@@ -1,105 +1,234 @@
 # encoding: utf-8
-require "logstash/filters/base"
-require "logstash/namespace"
-require "json"
-require "rest_client"
+require 'logstash/filters/base'
+require 'logstash/namespace'
+require 'logstash/plugin_mixins/http_client'
+require 'logstash/json'
 
 # Logstash REST Filter
 # This filter calls a defined URL and saves the answer into a specified field.
 #
 class LogStash::Filters::Rest < LogStash::Filters::Base
+  include LogStash::PluginMixins::HttpClient
 
-  # Usage:
+  config_name 'rest'
+
+  # Configure the rest request send via HttpClient Plugin
+  # with hash objects used by the mixin plugin
+  #
+  # For example, if you want the data to be put in the `doc` field:
+  # [source,ruby]
+  #    filter {
+  #      rest {
+  #        request => {
+  #          url => "http://example.com"       # string (required, with field reference: "http://example.com?id=%{id}" or params, if defined)
+  #          method => "post"                  # string (optional, default = "get")
+  #          headers => {                       # hash (optional)
+  #            "key1" => "value1"
+  #            "key2" => "value2"
+  #          }
+  #          auth => {
+  #            user => "AzureDiamond"
+  #            password => "hunter2"
+  #          }
+  #          params => {                       # hash (optional, available for method => "get" and "post"; if post it will be transformed into body hash and posted as json)
+  #            "key1" => "value1"
+  #            "key2" => "value2"
+  #            "key3" => "%{somefield}"        # Please set sprintf to true if you want to use field references
+  #          }
+  #        }
+  #      }
+  #    }
+  #
+  # NOTE: for further details, please reference https://github.com/logstash-plugins/logstash-mixin-http_client[logstash-mixin-http_client]
+  config :request, :validate => :hash, :required => true
+
+  # The plugin is written json centric, which defaults to true
+  # the response body will be parsed to json if true
   #
-  #  rest {
-  #  url => "http://example.com"       # string (required, with field reference: "http://example.com?id=%{id}")
-  #  json => true                      # boolean (optional, default = false)
-  #  method => "post"                  # string (optional, default = "get")
-  #  sprintf => true                   # boolean (optional, default = false, set this to true if you want to use field references in url, header or params)
-  #  header => {                       # hash (optional)
-  #    "key1" => "value1"
-  #    "key2" => "value2"
-  #    "key3" => "%{somefield}"        # Please set sprintf to true if you want to use field references
-  #  }
-  #  params => {                       # hash (optional, only available for method => "post")
-  #    "key1" => "value1"
-  #    "key2" => "value2"
-  #    "key3" => "%{somefield}"        # Please set sprintf to true if you want to use field references
-  #  }
-  #  response_key => "my_key"          # string (optional, default = "rest_response")
-  #  }
+  # [source,ruby]
+  #     filter {
+  #       rest {
+  #         request => { .. }
+  #         json => true
+  #       }
+  #     }
+  config :json, :validate => :boolean, :default => true
+
+  # If true, references to event fields can be made in
+  # url, params or body by using '%{somefield}'
   #
-  
-  config_name "rest"
-  
-  config :url, :validate => :string, :required => true
-  config :method, :validate => :string, :default => "get"
-  config :json, :validate => :boolean, :default => false
+  # [source,ruby]
+  #     filter {
+  #       rest {
+  #         request => { .. }
+  #         sprintf => true
+  #       }
+  #     }
   config :sprintf, :validate => :boolean, :default => false
-  config :header, :validate => :hash, :default => {  }
-  config :params, :validate => :hash, :default => {  }
-  config :response_key, :validate => :string, :default => "rest_response"
+
+  # Defines the field, where the parsed response is written to
+  # if set to '' it will be written to event root
+  #
+  # For example, if you want the data to be put in the `doc` field:
+  # [source,ruby]
+  #     filter {
+  #       rest {
+  #         request => { .. }
+  #         target => "doc"
+  #       }
+  #     }
+  #
+  # NOTE: if the `target` field already exists, it will be overwritten!
+  config :target, :validate => :string, :default => 'rest'
+
+  # If set, any error like json parsing or invalid http response
+  # will result in this hash to be added to target instead of error tags
+  #
+  # For example, if you want the fallback data to be put in the `target` field:
+  # [source,ruby]
+  #     filter {
+  #       rest {
+  #         request => { .. }
+  #         fallback => {
+  #           'key1' => 'value1'
+  #           'key2' => 'value2'
+  #           ...
+  #         }
+  #       }
+  #     }
+  config :fallback, :validate => :hash, :default => {}
+
+  # Append values to the `tags` field when there has been no
+  # successful match or json parsing error
+  config :tag_on_rest_failure, :validate => :array, :default => ['_restfailure']
+  config :tag_on_json_failure, :validate => :array, :default => ['_jsonparsefailure']
 
   public
-  def register
 
+  def register
+    @request = normalize_request(@request)
   end # def register
 
+  private
+
+  def normalize_request(url_or_spec)
+    if url_or_spec.is_a?(String)
+      res = [:get, url_or_spec]
+    elsif url_or_spec.is_a?(Hash)
+      # The client will expect keys / values
+      spec = Hash[url_or_spec.clone.map { |k, v| [k.to_sym, v] }]
+
+      # method and url aren't really part of the options, so we pull them out
+      method = (spec.delete(:method) || :get).to_sym.downcase
+      url = spec.delete(:url)
+
+      # if it is a post and json, it is used as body string, not params
+      spec[:body] = spec.delete(:params) if method == :post
+
+      # We need these strings to be keywords!
+      spec[:auth] = { user: spec[:auth]['user'], pass: spec[:auth]['password'] } if spec[:auth]
+
+      res = [method, url, spec]
+    else
+      raise LogStash::ConfigurationError, "Invalid URL or request spec: '#{url_or_spec}', expected a String or Hash!"
+    end
+
+    validate_request!(url_or_spec, res)
+    res
+  end
+
+  private
+
+  def validate_request!(url_or_spec, request)
+    method, url, spec = request
+
+    raise LogStash::ConfigurationError, "No URL provided for request! #{url_or_spec}" unless url
+    raise LogStash::ConfigurationError, "Not supported request method #{method}" unless [ :get, :post ].include?( method )
+
+    if spec && spec[:auth]
+      raise LogStash::ConfigurationError, "Auth was specified, but 'user' was not!" unless spec[:auth][:user]
+      raise LogStash::ConfigurationError, "Auth was specified, but 'password' was not!" unless spec[:auth][:pass]
+    end
+
+    request
+  end
+
+  private
+
+  def request_http(request)
+    @logger.debug? && @logger.debug('Fetching URL', :request => request)
+
+    request[2][:body] = LogStash::Json.dump(request[2][:body]) if request[2].key?(:body)
+
+    method, url, *request_opts = request
+    response = client.http(method, url, *request_opts)
+    [response.code, response.body]
+  end
+
+  private
+
+  def process_response(response, event)
+    if @json
+      begin
+        parsed = LogStash::Json.load(response)
+        event = add_to_event(parsed, event)
+      rescue
+        if @fallback.empty?
+          @tag_on_json_failure.each { |tag| event.tag(tag) }
+          @logger.warn('JSON parsing error', :response => response, :event => event)
+        else
+          event = add_to_event(@fallback, event)
+        end
+      end
+    else
+      event.set(@target, response.strip)
+    end
+    event
+  end
+
   public
+
   def filter(event)
     return unless filter?(event)
-	begin
-		case method
-		when "get"
-			response = RestClient.get sprint(@sprintf, @url, event), sprint(@sprintf, @header, event)
-		when "post"
-			response = RestClient.post sprint(@sprintf, @url, event), sprint(@sprintf, @params, event), sprint(@sprintf, @header, event)
-		else
-			response = "invalid method"	
-			@logger.error("Invalid method:", :method => method)
-		end
-		
-		if json == true
-			begin
-				h = JSON.parse(response)
-				if response_key == ""
-					h.each do |key, value|
-						event[key] = value
-					end
-				else
-					event[response_key] = { }
-					event[response_key] = h
-				end
-			rescue
-				event['jsonerror'] = "unable to parse json"
-			end
-		else
-			event[@response_key] = response.strip
-		end
-	rescue
-		@logger.error("Error in Rest Filter. Parameters:", :url => url, :method => method, :json => json, :header => header, :params => params)
-		@logger.error("Rest Error Message:", :message => $!.message)
-		@logger.error("Backtrace:", :backtrace => $!.backtrace)
-		event['resterror'] = "Rest Filter Error. Please see Logstash Error Log for further information."
-	end
-	
-    filter_matched(event)    
+    @request[2][:params] = sprint(@sprintf, @request[2][:params], event) if @request[2].key?(:params)
+    @request[2][:body] = sprint(@sprintf, @request[2][:body], event) if @request[2].key?(:body)
+    @request[1] = sprint(@sprintf, @request[1], event)
+
+    code, body = request_http(@request)
+    if code.between?(200, 299)
+      event = process_response(body, event)
+      @logger.debug? && @logger.debug('Sucess received', :code => code, :body => body)
+    else
+      @logger.debug? && @logger.debug('Http error received', :code => code, :body => body)
+      if @fallback.empty?
+        @tag_on_rest_failure.each { |tag| event.tag(tag) }
+        @logger.error('Error in Rest filter', :request => @request, :json => @json, :code => code, :body => body)
+      else
+        event = add_to_event(@fallback, event)
+        @logger.debug? && @logger.debug('Setting fallback', :fallback => @fallback)
+      end
+    end
+    filter_matched(event)
   end # def filter
-  
+
+  private
+
   def sprint(sprintf, hash, event)
-        if sprintf
-                if hash.class == Hash
-                        result = { }
-                        hash.each do |key, value|
-                                result[key] = event.sprintf(value)
-                        end
-                        return result
-                else
-                        return event.sprintf(hash)
-                end
-        else
-                return hash
-        end
+    return hash unless sprintf
+    return event.sprintf(hash) unless hash.is_a?(Hash)
+    result = {}
+    hash.each { |k, v| result[k] = event.sprintf(v) }
+    result
   end
 
+  private
+
+  def add_to_event(to_add, event)
+    if @target.empty?
+      to_add.each { |k, v| event[k] = v }
+    else
+      event[@target] = to_add
+    end
+    event
+  end
 end # class LogStash::Filters::Rest

data/logstash-filter-rest.gemspec

@@ -1,25 +1,27 @@
 Gem::Specification.new do |s|
   s.name = 'logstash-filter-rest'
-  s.version         = '0.1.6'
+  s.version = '0.2.0'
   s.licenses = ['Apache License (2.0)']
-  s.summary = "This filter requests data from a RESTful Web Service."
-  s.description = "This gem is a logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/plugin install gemname. This gem is not a stand-alone program"
-  s.authors = ["Lucas Henning"]
+  s.summary = 'This filter requests data from a RESTful Web Service.'
+  s.description = 'This gem is a logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/plugin install gemname. This gem is not a stand-alone program'
+  s.authors = ['Lucas Henning', 'Gandalf Buscher']
   s.email = 'mail@hurb.de'
-  s.homepage = "https://github.com/lucashenning/logstash-filter-rest/"
-  s.require_paths = ["lib"]
+  s.homepage = 'https://github.com/lucashenning/logstash-filter-rest/'
+  s.require_paths = ['lib']
 
   # Files
-  s.files = `git ls-files`.split($\)
-   # Tests
+  s.files = Dir['lib/**/*','spec/**/*','vendor/**/*','*.gemspec','*.md','CONTRIBUTORS','Gemfile','LICENSE','NOTICE.TXT']
+  # Tests
   s.test_files = s.files.grep(%r{^(test|spec|features)/})
 
   # Special flag to let us know this is actually a logstash plugin
-  s.metadata = { "logstash_plugin" => "true", "logstash_group" => "filter" }
+  s.metadata = { 'logstash_plugin' => 'true', 'logstash_group' => 'filter' }
 
   # Gem dependencies
-  s.add_runtime_dependency "logstash-core", '>= 1.5.0', '< 3.0.0'
-  s.add_runtime_dependency "rest-client", '>= 1.8.0'
-  s.add_runtime_dependency 'logstash-codec-json'
-  s.add_development_dependency 'logstash-devutils'
+  s.add_runtime_dependency 'logstash-core', '>= 1.6.0', '< 3.0.0'
+  s.add_runtime_dependency 'logstash-codec-json', '>= 1.6.0', '< 3.0.0'
+  s.add_runtime_dependency 'logstash-mixin-http_client', '>= 2.2.4', '< 5.0.0'
+
+  s.add_development_dependency 'logstash-devutils', '~> 0'
+  s.add_development_dependency 'pry', '~> 0'
 end

data/spec/filters/rest_spec.rb

@@ -1,12 +1,14 @@
 require 'spec_helper'
-require "logstash/filters/rest"
+require 'logstash/filters/rest'
 
 describe LogStash::Filters::Rest do
-  describe "Set to Rest Filter" do
+  describe "Set to Rest Filter Get without params" do
     let(:config) do <<-CONFIG
       filter {
         rest {
-          url => "http://jsonplaceholder.typicode.com/users/1"
+          request => {
+            url => "http://jsonplaceholder.typicode.com/users/10"
+          }
           json => true
         }
       }
@@ -14,8 +16,250 @@ describe LogStash::Filters::Rest do
     end
 
     sample("message" => "some text") do
-      expect(subject).to include("rest_response")
-      expect(subject['rest_response']).to include("id")
+      expect(subject).to include('rest')
+      expect(subject['rest']).to include("id")
+      expect(subject['rest']['id']).to eq(10)
+      expect(subject['rest']).to_not include("fallback")
+    end
+  end
+  describe "Set to Rest Filter Get without params custom target" do
+    let(:config) do <<-CONFIG
+      filter {
+        rest {
+          request => {
+            url => "http://jsonplaceholder.typicode.com/users/10"
+          }
+          json => true
+          target => 'testing'
+        }
+      }
+    CONFIG
+    end
+
+    sample("message" => "some text") do
+      expect(subject).to include('testing')
+      expect(subject['testing']).to include("id")
+      expect(subject['testing']['id']).to eq(10)
+      expect(subject['testing']).to_not include("fallback")
+    end
+  end
+  describe "Set to Rest Filter Get without params and sprintf" do
+    let(:config) do <<-CONFIG
+      filter {
+        rest {
+          request => {
+            url => "http://jsonplaceholder.typicode.com/users/%{message}"
+          }
+          json => true
+          sprintf => true
+        }
+      }
+    CONFIG
+    end
+
+    sample("message" => "10") do
+      expect(subject).to include('rest')
+      expect(subject['rest']).to include("id")
+      expect(subject['rest']['id']).to eq(10)
+      expect(subject['rest']).to_not include("fallback")
+    end
+  end
+  describe "Set to Rest Filter Get without params http error" do
+    let(:config) do <<-CONFIG
+      filter {
+        rest {
+          request => {
+            url => "http://httpstat.us/404"
+          }
+          json => true
+        }
+      }
+    CONFIG
+    end
+
+    sample("message" => "some text") do
+      expect(subject).to_not include('rest')
+      expect(subject['tags']).to include('_restfailure')
+    end
+  end
+  describe "Set to Rest Filter Get with params" do
+    let(:config) do <<-CONFIG
+      filter {
+        rest {
+          request => {
+            url => "https://jsonplaceholder.typicode.com/posts"
+            params => {
+              userId => 10
+            }
+            headers => {
+              "Content-Type" => "application/json"
+            }
+          }
+          json => true
+        }
+      }
+    CONFIG
+    end
+
+    sample("message" => "some text") do
+      expect(subject).to include('rest')
+      expect(subject['rest'][0]).to include("userId")
+      expect(subject['rest'][0]['userId']).to eq(10)
+      expect(subject['rest']).to_not include("fallback")
+    end
+  end
+  describe "Set to Rest Filter Get with params sprintf" do
+    let(:config) do <<-CONFIG
+      filter {
+        rest {
+          request => {
+            url => "https://jsonplaceholder.typicode.com/posts"
+            params => {
+              userId => "%{message}"
+            }
+            headers => {
+              "Content-Type" => "application/json"
+            }
+          }
+          json => true
+          sprintf => true
+        }
+      }
+    CONFIG
+    end
+
+    sample("message" => "10") do
+      expect(subject).to include('rest')
+      expect(subject['rest'][0]).to include("userId")
+      expect(subject['rest'][0]['userId']).to eq(10)
+      expect(subject['rest']).to_not include("fallback")
+    end
+  end
+  describe "Set to Rest Filter Post with params" do
+    let(:config) do <<-CONFIG
+      filter {
+        rest {
+          request => {
+            url => "https://jsonplaceholder.typicode.com/posts"
+            method => "post"
+            params => {
+              title => 'foo'
+              body => 'bar'
+              userId => 42
+            }
+            headers => {
+              "Content-Type" => "application/json"
+            }
+          }
+          json => true
+        }
+      }
+    CONFIG
+    end
+
+    sample("message" => "some text") do
+      expect(subject).to include('rest')
+      expect(subject['rest']).to include("id")
+      expect(subject['rest']['userId']).to eq(42)
+      expect(subject['rest']).to_not include("fallback")
+    end
+  end
+  describe "Set to Rest Filter Post with params sprintf" do
+    let(:config) do <<-CONFIG
+      filter {
+        rest {
+          request => {
+            url => "https://jsonplaceholder.typicode.com/posts"
+            method => "post"
+            params => {
+              title => 'foo'
+              body => 'bar'
+              userId => "%{message}"
+            }
+            headers => {
+              "Content-Type" => "application/json"
+            }
+          }
+          json => true
+          sprintf => true
+        }
+      }
+    CONFIG
+    end
+
+    sample("message" => "42") do
+      expect(subject).to include('rest')
+      expect(subject['rest']).to include("id")
+      expect(subject['rest']['userId']).to eq(42)
+      expect(subject['rest']).to_not include("fallback")
+    end
+  end
+  describe "Fallback" do
+    let(:config) do <<-CONFIG
+      filter {
+        rest {
+          request => {
+            url => "http://jsonplaceholder.typicode.com/users/0"
+          }
+          json => true
+          fallback => {
+            "fallback1" => true
+            "fallback2" => true
+          }
+        }
+      }
+    CONFIG
+    end
+
+    sample("message" => "some text") do
+      expect(subject).to include('rest')
+      expect(subject['rest']).to include("fallback1")
+      expect(subject['rest']).to include("fallback2")
+      expect(subject['rest']).to_not include("id")
+    end
+  end
+  describe "Fallback empty target" do
+    let(:config) do <<-CONFIG
+      filter {
+        rest {
+          request => {
+            url => "http://jsonplaceholder.typicode.com/users/0"
+          }
+          json => true
+          target => ''
+          fallback => {
+            "fallback1" => true
+            "fallback2" => true
+          }
+        }
+      }
+    CONFIG
+    end
+
+    sample("message" => "some text") do
+      expect(subject).to_not include('rest')
+      expect(subject).to include("fallback1")
+      expect(subject).to include("fallback2")
+      expect(subject).to_not include("id")
+    end
+  end
+  describe "Empty target" do
+    let(:config) do <<-CONFIG
+      filter {
+        rest {
+          request => {
+            url => "http://jsonplaceholder.typicode.com/users/1"
+          }
+          json => true
+          target => ''
+        }
+      }
+    CONFIG
+    end
+
+    sample("message" => "some text") do
+      expect(subject).to include("id")
+      expect(subject).to_not include("fallback")
     end
   end
 end

data/spec/spec_helper.rb

@@ -1 +1,2 @@
-require "logstash/devutils/rspec/spec_helper"
+require 'logstash/devutils/rspec/spec_helper'
+require 'pry'

metadata

@@ -1,77 +1,104 @@
 --- !ruby/object:Gem::Specification
 name: logstash-filter-rest
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - Lucas Henning
+- Gandalf Buscher
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-04-08 00:00:00.000000000 Z
+date: 2016-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
   name: logstash-core
+  prerelease: false
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.0
-    - - <
+        version: 1.6.0
+    - - "<"
       - !ruby/object:Gem::Version
         version: 3.0.0
+- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.0
-    - - <
+        version: 1.6.0
+    - - "<"
       - !ruby/object:Gem::Version
         version: 3.0.0
+  name: logstash-codec-json
   prerelease: false
   type: :runtime
-- !ruby/object:Gem::Dependency
-  name: rest-client
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: 1.6.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.4
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: 5.0.0
+  name: logstash-mixin-http_client
   prerelease: false
   type: :runtime
-- !ruby/object:Gem::Dependency
-  name: logstash-codec-json
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.2.4
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
-  prerelease: false
-  type: :runtime
-- !ruby/object:Gem::Dependency
   name: logstash-devutils
+  prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+  name: pry
   prerelease: false
   type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
 description: This gem is a logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/plugin install gemname. This gem is not a stand-alone program
 email: mail@hurb.de
 executables: []
@@ -82,7 +109,6 @@ files:
 - Gemfile
 - LICENSE
 - README.md
-- Rakefile
 - lib/logstash/filters/rest.rb
 - logstash-filter-rest.gemspec
 - spec/filters/rest_spec.rb
@@ -99,17 +125,17 @@ 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.4.6
+rubygems_version: 2.6.4
 signing_key:
 specification_version: 4
 summary: This filter requests data from a RESTful Web Service.

data/Rakefile

@@ -1 +0,0 @@
-require "logstash/devutils/rake"