logstash-input-http 2.2.3 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 369d5bdf4eb3849fe8c1c22be51872b77f306e99
-  data.tar.gz: 7f4c99931dd5bbbd45afc51dd689bc3ddaf21291
+  metadata.gz: 75f2c566d1b23333d2705be8973004bc525a8ff1
+  data.tar.gz: c6f406a0effc8b4be87a1048d4a7a2f37103e4fb
 SHA512:
-  metadata.gz: 8101c5b9b09393a672d4807bad8980265e5592dc9ba979e6cd70798ff02cd07919be12a9f1a6dfd5608447fe44aa5849f5a262eae417c93928c01a2564889678
-  data.tar.gz: 4b8f65d565b7b49dfc0d31b09665fda3361b775b3816bddde7a2cd4e51f925333ae52f486176bf1b903c529b3fc22b194dc2e8f76678d852ef5dda8f68b9369c
+  metadata.gz: e4116f87e6ff47f554989b160c61ac3bcc8752e04e1d3d4573c4149848fc821b686c08e9630b60373101d2bc1fc1be345580beb7a7e8ff2fa3f4c0cf67159365
+  data.tar.gz: 31425ebc701bbefe30813879e40e1aa036c87457b9d570a1523c6985f18fb29671c32d21ce824acd9bb43fc30fa8919a4cff2f06c6c04a4de12d21dcb41fef64

data/CHANGELOG.md

@@ -1,6 +1,5 @@
-# 2.2.3
-  - fix hanging tests
-  - added some meta documents to the repository like contributing guide and github templates
+## 3.0.0
+  - Update the plugin to the version 2.0 of the plugin api, this change is required for Logstash 5.0 compatibility. See https://github.com/elastic/logstash/issues/5141
 # 2.2.2
   - Depend on logstash-core-plugin-api instead of logstash-core, removing the need to mass update plugins on major releases of logstash
 # 2.2.1

data/Gemfile

@@ -1,2 +1,4 @@
 source 'https://rubygems.org'
-gemspec
+
+# Specify your gem's dependencies in logstash-mass_effect.gemspec
+gemspec

data/lib/logstash/inputs/http.rb

@@ -130,8 +130,8 @@ class LogStash::Inputs::Http < LogStash::Inputs::Base
         req = lowercase_keys(req)
         body = req.delete("rack.input")
         @codecs.fetch(req["content_type"], @codec).decode(body.read) do |event|
-          event["host"] = remote_host
-          event["headers"] = req
+          event.set("host", remote_host)
+          event.set("headers", req)
           decorate(event)
           queue << event
         end

data/logstash-input-http.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'logstash-input-http'
-  s.version         = '2.2.3'
+  s.version         = '3.0.0'
   s.licenses = ['Apache License (2.0)']
   s.summary = "Logstash Input plugin that receives HTTP requests"
   s.description     = "This gem is a Logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/logstash-plugin install gemname. This gem is not a stand-alone program"
@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.metadata = { "logstash_plugin" => "true", "logstash_group" => "input" }
 
   # Gem dependencies
-  s.add_runtime_dependency "logstash-core-plugin-api", "~> 1.0"
+  s.add_runtime_dependency "logstash-core-plugin-api", "~> 2.0"
   s.add_runtime_dependency 'logstash-codec-plain'
   s.add_runtime_dependency 'stud'
   s.add_runtime_dependency 'puma', '~> 2.16', '>= 2.16.0'

data/spec/inputs/http_spec.rb

@@ -16,179 +16,149 @@ describe LogStash::Inputs::Http do
   let(:queue) { Queue.new }
   let(:port) { rand(5000) + 1025 }
 
-  it_behaves_like "an interruptible input plugin" do
-    let(:config) { { "port" => port } }
-  end
-
   after :each do
     subject.stop
   end
 
-  describe "request handling" do
+  it_behaves_like "an interruptible input plugin" do
+    let(:config) { { "port" => port } }
+  end
+
+  describe "#run" do
     subject { LogStash::Inputs::Http.new }
     before :each do
       subject.register
-      t = Thread.new { subject.run(queue) }
-      sleep 0.01 until subject.instance_variable_get(:@server).running == 0
+      Thread.new { subject.run(queue) }
     end
-
     it "should include remote host in \"host\" property" do
       agent.post!("http://localhost:8080/meh.json",
-                  :headers => { "content-type" => "text/plain" },
-                  :body => "hello")
+        :headers => { "content-type" => "text/plain" },
+        :body => "hello")
       event = queue.pop
-      expect(event["host"]).to eq("127.0.0.1")
+      expect(event.get("host")).to eq("127.0.0.1")
     end
+  end
 
-    context "with default codec" do
-      subject { LogStash::Inputs::Http.new("port" => port) }
-      context "when receiving a text/plain request" do
-        it "should process the request normally" do
-          agent.post!("http://localhost:#{port}/meh.json",
-                      :headers => { "content-type" => "text/plain" },
-                      :body => "hello")
-          event = queue.pop
-          expect(event["message"]).to eq("hello")
-        end
-      end
-      context "when receiving a deflate compressed text/plain request" do
-        it "should process the request normally" do
-          agent.post!("http://localhost:#{port}/meh.json",
-                      :headers => { "content-type" => "text/plain", "content-encoding" => "deflate" },
-                      :body => Zlib::Deflate.deflate("hello"))
-          event = queue.pop
-          expect(event["message"]).to eq("hello")
-        end
-      end
-      context "when receiving a deflate text/plain request that cannot be decompressed" do
-        it "should respond with 400" do
-          response = agent.post!("http://localhost:#{port}/meh.json",
-                                 :headers => { "content-type" => "text/plain", "content-encoding" => "deflate" },
-                                   :body => "hello")
-          expect(response.status).to eq(400)
-        end
-        it "should respond with a decompression error" do
-          response = agent.post!("http://localhost:#{port}/meh.json",
-                                 :headers => { "content-type" => "text/plain", "content-encoding" => "deflate" },
-                                   :body => "hello")
-          expect(response.read_body).to eq("Failed to decompress body")
-        end
-      end
-      context "when receiving a gzip compressed text/plain request" do
-        it "should process the request normally" do
-          z = StringIO.new ""
-          w = Zlib::GzipWriter.new z
-          w.write("hello")
-          w.finish
-          agent.post!("http://localhost:#{port}/meh.json",
-                      :headers => { "content-type" => "text/plain", "content-encoding" => "gzip" },
-                        :body => z.string)
-          event = queue.pop
-          expect(event["message"]).to eq("hello")
-        end
-      end
-      context "when receiving a gzip text/plain request that cannot be decompressed" do
-        let(:response) do
-          agent.post!("http://localhost:#{port}/meh.json",
-                      :headers => { "content-type" => "text/plain", "content-encoding" => "gzip" },
-                      :body => "hello")
-        end
-        it "should respond with 400" do
-          expect(response.status).to eq(400)
-        end
-        it "should respond with a decompression error" do
-          expect(response.read_body).to eq("Failed to decompress body")
-        end
-      end
-      context "when receiving an application/json request" do
-        it "should parse the json body" do
-          agent.post!("http://localhost:#{port}/meh.json",
-                      :headers => { "content-type" => "application/json" },
-                      :body => { "message_body" => "Hello" }.to_json)
-          event = queue.pop
-          expect(event["message_body"]).to eq("Hello")
-        end
+  context "with default codec" do
+    subject { LogStash::Inputs::Http.new("port" => port) }
+    context "when receiving a text/plain request" do
+      it "should process the request normally" do
+        subject.register
+        Thread.new { subject.run(queue) }
+        agent.post!("http://localhost:#{port}/meh.json",
+                    :headers => { "content-type" => "text/plain" },
+                    :body => "hello")
+        event = queue.pop
+        expect(event.get("message")).to eq("hello")
       end
     end
-    context "with json codec" do
-      subject { LogStash::Inputs::Http.new("port" => port, "codec" => "json") }
-      it "should parse the json body" do
-        agent.post!("http://localhost:#{port}/meh.json", :body => { "message" => "Hello" }.to_json)
+    context "when receiving a deflate compressed text/plain request" do
+      it "should process the request normally" do
+        subject.register
+        Thread.new { subject.run(queue) }
+        agent.post!("http://localhost:#{port}/meh.json",
+                    :headers => { "content-type" => "text/plain", "content-encoding" => "deflate" },
+                    :body => Zlib::Deflate.deflate("hello"))
         event = queue.pop
-        expect(event["message"]).to eq("Hello")
+        expect(event.get("message")).to eq("hello")
       end
     end
-
-    context "when using a custom codec mapping" do
-      subject { LogStash::Inputs::Http.new("port" => port,
-                                           "additional_codecs" => { "application/json" => "plain" }) }
-      it "should decode the message accordingly" do
-        body = { "message" => "Hello" }.to_json
+    context "when receiving a deflate text/plain request that cannot be decompressed" do
+      let!(:response) do
+        subject.register
+        Thread.new { subject.run(queue) }
+        agent.post!("http://localhost:#{port}/meh.json",
+                    :headers => { "content-type" => "text/plain", "content-encoding" => "deflate" },
+                    :body => "hello")
+      end
+      it "should respond with 400" do
+        expect(response.status).to eq(400)
+      end
+      it "should respond with a decompression error" do
+        expect(response.read_body).to eq("Failed to decompress body")
+      end
+    end
+    context "when receiving a gzip compressed text/plain request" do
+      it "should process the request normally" do
+        subject.register
+        Thread.new { subject.run(queue) }
+        z = StringIO.new ""
+        w = Zlib::GzipWriter.new z
+        w.write("hello")
+        w.finish
+        agent.post!("http://localhost:#{port}/meh.json",
+                    :headers => { "content-type" => "text/plain", "content-encoding" => "gzip" },
+                    :body => z.string)
+        event = queue.pop
+        expect(event.get("message")).to eq("hello")
+      end
+    end
+    context "when receiving a gzip text/plain request that cannot be decompressed" do
+      let!(:response) do
+          subject.register
+          Thread.new { subject.run(queue) }
+          agent.post!("http://localhost:#{port}/meh.json",
+                    :headers => { "content-type" => "text/plain", "content-encoding" => "gzip" },
+                    :body => "hello")
+      end
+      it "should respond with 400" do
+        expect(response.status).to eq(400)
+      end
+      it "should respond with a decompression error" do
+        expect(response.read_body).to eq("Failed to decompress body")
+      end
+    end
+    context "when receiving an application/json request" do
+      it "should parse the json body" do
+        subject.register
+        Thread.new { subject.run(queue) }
         agent.post!("http://localhost:#{port}/meh.json",
                     :headers => { "content-type" => "application/json" },
-                      :body => body)
+                    :body => { "message_body" => "Hello" }.to_json)
         event = queue.pop
-        expect(event["message"]).to eq(body)
+        expect(event.get("message_body")).to eq("Hello")
       end
     end
+  end
+
+  context "with json codec" do
+    subject { LogStash::Inputs::Http.new("port" => port, "codec" => "json") }
+    it "should parse the json body" do
+      subject.register
+      Thread.new { subject.run(queue) }
+      agent.post!("http://localhost:#{port}/meh.json", :body => { "message" => "Hello" }.to_json)
+      event = queue.pop
+      expect(event.get("message")).to eq("Hello")
+    end
+  end
+
+  context "when using a custom codec mapping" do
+    subject { LogStash::Inputs::Http.new("port" => port,
+                                         "additional_codecs" => { "application/json" => "plain" }) }
+    it "should decode the message accordingly" do
+      body = { "message" => "Hello" }.to_json
+      subject.register
+      Thread.new { subject.run(queue) }
+      agent.post!("http://localhost:#{port}/meh.json",
+                  :headers => { "content-type" => "application/json" },
+                  :body => body)
+      event = queue.pop
+      expect(event.get("message")).to eq(body)
+    end
+  end
 
-    context "when using custom headers" do
-      let(:custom_headers) { { 'access-control-allow-origin' => '*' } }
-      subject { LogStash::Inputs::Http.new("port" => port, "response_headers" => custom_headers) }
+  context "when using custom headers" do
+    let(:custom_headers) { { 'access-control-allow-origin' => '*' } }
+    subject { LogStash::Inputs::Http.new("port" => port, "response_headers" => custom_headers) }
 
-      describe "the response" do
-        it "should include the custom headers" do
-          response = agent.post!("http://localhost:#{port}/meh", :body => "hello")
-          expect(response.headers.to_hash).to include(custom_headers)
-        end
-      end
-    end
-    describe "basic auth" do
-      user = "test"; password = "pwd"
-      subject { LogStash::Inputs::Http.new("port" => port, "user" => user, "password" => password) }
-      let(:auth_token) { Base64.strict_encode64("#{user}:#{password}") }
-      context "when client doesn't present auth token" do
-        let!(:response) { agent.post!("http://localhost:#{port}/meh", :body => "hi") }
-        it "should respond with 401" do
-          expect(response.status).to eq(401)
-        end
-        it "should not generate an event" do
-          expect(queue).to be_empty
-        end
-      end
-      context "when client presents incorrect auth token" do
-        let!(:response) do
-          agent.post!("http://localhost:#{port}/meh",
-                      :headers => {
-                        "content-type" => "text/plain",
-                        "authorization" => "Basic meh"
-                      },
-                      :body => "hi")
-        end
-        it "should respond with 401" do
-          expect(response.status).to eq(401)
-        end
-        it "should not generate an event" do
-          expect(queue).to be_empty
-        end
-      end
-      context "when client presents correct auth token" do
-        let!(:response) do
-          agent.post!("http://localhost:#{port}/meh",
-                      :headers => {
-                        "content-type" => "text/plain",
-                        "authorization" => "Basic #{auth_token}"
-                      }, :body => "hi")
-        end
-        it "should respond with 200" do
-          expect(response.status).to eq(200)
-        end
-        it "should generate an event" do
-          expect(queue).to_not be_empty
-        end
+    describe "the response" do
+      it "should include the custom headers" do
+        subject.register
+        Thread.new { subject.run(queue) }
+        response = agent.post!("http://localhost:#{port}/meh", :body => "hello")
+        expect(response.headers.to_hash).to include(custom_headers)
       end
     end
-
   end
 
   context "with :ssl => false" do
@@ -214,4 +184,53 @@ describe LogStash::Inputs::Http do
       end
     end
   end
+  describe "basic auth" do
+    user = "test"; password = "pwd"
+    subject { LogStash::Inputs::Http.new("port" => port, "user" => user, "password" => password) }
+    let(:auth_token) { Base64.strict_encode64("#{user}:#{password}") }
+    before :each do
+      subject.register
+      Thread.new { subject.run(queue) }
+    end
+    context "when client doesn't present auth token" do
+      let!(:response) { agent.post!("http://localhost:#{port}/meh", :body => "hi") }
+      it "should respond with 401" do
+        expect(response.status).to eq(401)
+      end
+      it "should not generate an event" do
+        expect(queue).to be_empty
+      end
+    end
+    context "when client presents incorrect auth token" do
+      let!(:response) do
+        agent.post!("http://localhost:#{port}/meh",
+                    :headers => {
+                      "content-type" => "text/plain",
+                      "authorization" => "Basic meh"
+                    },
+                    :body => "hi")
+      end
+      it "should respond with 401" do
+        expect(response.status).to eq(401)
+      end
+      it "should not generate an event" do
+        expect(queue).to be_empty
+      end
+    end
+    context "when client presents correct auth token" do
+      let!(:response) do
+        agent.post!("http://localhost:#{port}/meh",
+                    :headers => {
+                      "content-type" => "text/plain",
+                      "authorization" => "Basic #{auth_token}"
+                    }, :body => "hi")
+      end
+      it "should respond with 200" do
+        expect(response.status).to eq(200)
+      end
+      it "should generate an event" do
+        expect(queue).to_not be_empty
+      end
+    end
+  end
 end

metadata

@@ -1,58 +1,59 @@
 --- !ruby/object:Gem::Specification
 name: logstash-input-http
 version: !ruby/object:Gem::Version
-  version: 2.2.3
+  version: 3.0.0
 platform: ruby
 authors:
 - Elastic
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-02 00:00:00.000000000 Z
+date: 2016-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: logstash-core-plugin-api
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
-  name: logstash-core-plugin-api
-  prerelease: false
+        version: '2.0'
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
+  name: logstash-codec-plain
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: logstash-codec-plain
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: stud
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: stud
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: puma
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -61,9 +62,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.16.0
-  name: puma
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -73,62 +73,64 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.16.0
 - !ruby/object:Gem::Dependency
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
-  name: rack
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
 - !ruby/object:Gem::Dependency
+  name: logstash-devutils
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: logstash-devutils
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: logstash-codec-json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: logstash-codec-json
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: ftw
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: ftw
-  prerelease: false
   type: :development
+  prerelease: false
   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/logstash-plugin install gemname. This gem is not a stand-alone program
+description: This gem is a Logstash plugin required to be installed on top of the
+  Logstash core pipeline using $LS_HOME/bin/logstash-plugin install gemname. This
+  gem is not a stand-alone program
 email: info@elastic.co
 executables: []
 extensions: []
@@ -150,7 +152,7 @@ licenses:
 metadata:
   logstash_plugin: 'true'
   logstash_group: input
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -165,9 +167,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.6.3
-signing_key:
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
 specification_version: 4
 summary: Logstash Input plugin that receives HTTP requests
 test_files: