logstash-output-amazon_es 2.0.1-java → 6.4.0-java

data/lib/logstash/outputs/amazon_es/elasticsearch-template.json

@@ -1,41 +0,0 @@
-{
-  "template" : "logstash-*",
-  "settings" : {
-    "index.refresh_interval" : "5s"
-  },
-  "mappings" : {
-    "_default_" : {
-       "_all" : {"enabled" : true, "omit_norms" : true},
-       "dynamic_templates" : [ {
-         "message_field" : {
-           "match" : "message",
-           "match_mapping_type" : "string",
-           "mapping" : {
-             "type" : "string", "index" : "analyzed", "omit_norms" : true
-           }
-         }
-       }, {
-         "string_fields" : {
-           "match" : "*",
-           "match_mapping_type" : "string",
-           "mapping" : {
-             "type" : "string", "index" : "analyzed", "omit_norms" : true,
-               "fields" : {
-                 "raw" : {"type": "string", "index" : "not_analyzed", "ignore_above" : 256}
-               }
-           }
-         }
-       } ],
-       "properties" : {
-         "@version": { "type": "string", "index": "not_analyzed" },
-         "geoip"  : {
-           "type" : "object",
-             "dynamic": true,
-             "properties" : {
-               "location" : { "type" : "geo_point" }
-             }
-         }
-       }
-    }
-  }
-}

data/spec/amazon_es_spec_helper.rb

@@ -1,69 +0,0 @@
-require "logstash/devutils/rspec/spec_helper"
-require "ftw"
-require "logstash/plugin"
-require "logstash/json"
-require "stud/try"
-require "longshoreman"
-
-CONTAINER_NAME = "logstash-output-amazon-es-#{rand(999).to_s}"
-CONTAINER_IMAGE = "elasticsearch"
-CONTAINER_TAG = "1.6"
-
-DOCKER_INTEGRATION = ENV["DOCKER_INTEGRATION"]
-
-module ESHelper
-  def get_host
-    DOCKER_INTEGRATION ? Longshoreman.new.get_host_ip : "127.0.0.1"
-  end
-
-  def get_port
-    return 9200 unless DOCKER_INTEGRATION
-
-    container = Longshoreman::Container.new
-    container.get(CONTAINER_NAME)
-    container.rport(9200)
-  end
-
-  def get_client
-    Elasticsearch::Client.new(:host => "#{get_host}:#{get_port}")
-  end
-end
-
-
-RSpec.configure do |config|
-  config.include ESHelper
-
-
-  if DOCKER_INTEGRATION
-    # this :all hook gets run before every describe block that is tagged with :integration => true.
-    config.before(:all, :integration => true) do
-
-
-      # check if container exists already before creating new one.
-      begin
-        ls = Longshoreman::new
-        ls.container.get(CONTAINER_NAME)
-      rescue Docker::Error::NotFoundError
-        Longshoreman.new("#{CONTAINER_IMAGE}:#{CONTAINER_TAG}", CONTAINER_NAME)
-        # TODO(talevy): verify ES is running instead of static timeout
-        sleep 10
-      end
-    end
-
-    # we want to do a final cleanup after all :integration runs,
-    # but we don't want to clean up before the last block.
-    # This is a final blind check to see if the ES docker container is running and
-    # needs to be cleaned up. If no container can be found and/or docker is not
-    # running on the system, we do nothing.
-    config.after(:suite) do
-      # only cleanup docker container if system has docker and the container is running
-      begin
-        ls = Longshoreman::new
-        ls.container.get(CONTAINER_NAME)
-        ls.cleanup
-      rescue Docker::Error::NotFoundError, Excon::Errors::SocketError
-        # do nothing
-      end
-    end
-  end
-end

data/spec/unit/outputs/amazon_es_spec.rb

@@ -1,50 +0,0 @@
-require_relative "../../../spec/amazon_es_spec_helper"
-
-describe "outputs/amazon_es" do
-  describe "http client create" do
-    require "logstash/outputs/amazon_es"
-    require "elasticsearch"
-
-    let(:options) {
-      {
-        "index" => "my-index",
-        "hosts" => "localhost",
-        "path" => "some-path"
-      }
-    }
-
-    let(:eso) {LogStash::Outputs::AmazonES.new(options)}
-
-    let(:manticore_host) {
-      eso.client.send(:client).transport.options[:hosts].first
-    }
-
-    around(:each) do |block|
-      thread = eso.register
-      block.call()
-      thread.kill()
-    end
-
-    describe "with path" do
-      it "should properly create a URI with the path" do
-        expect(eso.path).to eql(options["path"])
-      end
-
-
-      it "should properly set the path on the HTTP client" do
-        expect(manticore_host).to include("/" + options["path"])
-      end
-
-      context "with extra slashes" do
-        let(:path) { "/slashed-path/ "}
-        let(:eso) {
-          LogStash::Outputs::AmazonES.new(options.merge("path" => "/some-path/"))
-        }
-
-        it "should properly set the path on the HTTP client without adding slashes" do
-          expect(manticore_host).to include(options["path"])
-        end
-      end
-    end
-  end
-end

data/spec/unit/outputs/elasticsearch/protocol_spec.rb

@@ -1,36 +0,0 @@
-require "logstash/devutils/rspec/spec_helper"
-require "logstash/outputs/amazon_es/http_client"
-require "java"
-
-describe LogStash::Outputs::AES::HttpClient do
-  context "successful" do
-    it "should map correctly" do
-      bulk_response = {"took"=>74, "errors"=>false, "items"=>[{"create"=>{"_index"=>"logstash-2014.11.17",
-                                                                          "_type"=>"logs", "_id"=>"AUxTS2C55Jrgi-hC6rQF",
-                                                                          "_version"=>1, "status"=>201}}]} 
-      actual = LogStash::Outputs::AES::HttpClient.normalize_bulk_response(bulk_response)
-      insist { actual } == {"errors"=> false}
-    end
-  end
-
-  context "contains failures" do
-    it "should map correctly" do
-      bulk_response = {"took"=>71, "errors"=>true,
-                       "items"=>[{"create"=>{"_index"=>"logstash-2014.11.17",
-                                             "_type"=>"logs", "_id"=>"AUxTQ_OI5Jrgi-hC6rQB", "status"=>400,
-                                             "error"=>"MapperParsingException[failed to parse]..."}}]}
-      actual = LogStash::Outputs::AES::HttpClient.normalize_bulk_response(bulk_response)
-      insist { actual } == {"errors"=> true, "statuses"=> [400]}
-    end
-  end
-
-  describe "sniffing" do
-    let(:base_options) { {:hosts => ["127.0.0.1"] }}
-    let(:client) { LogStash::Outputs::AES::HttpClient.new(base_options.merge(client_opts)) }
-    let(:transport) { client.client.transport }
-
-    before do
-      allow(transport).to receive(:reload_connections!)
-    end
-  end
-end

data/spec/unit/outputs/elasticsearch_proxy_spec.rb

@@ -1,58 +0,0 @@
-require_relative "../../../spec/amazon_es_spec_helper"
-require 'stud/temporary'
-require 'elasticsearch'
-require "logstash/outputs/amazon_es"
-
-describe "Proxy option" do
-  let(:settings) {
-    {
-      "hosts" => "node01",
-      "proxy" => proxy
-    }
-  }
-  subject {
-    LogStash::Outputs::AmazonES.new(settings)
-  }
-
-  before do
-    allow(::Elasticsearch::Client).to receive(:new).with(any_args)
-  end
-
-  describe "valid configs" do
-    before do
-      subject.register
-    end
-
-    context "when specified as a string" do
-      let(:proxy) { "http://127.0.0.1:1234" }
-
-      it "should set the proxy to the exact value" do
-        expect(::Elasticsearch::Client).to have_received(:new) do |options|
-          expect(options[:transport_options][:proxy]).to eql(proxy)
-        end
-      end
-    end
-
-    context "when specified as a hash" do
-      let(:proxy) { {"hosts" => "127.0.0.1", "protocol" => "http"} }
-
-      it "should pass through the proxy values as symbols" do
-        expected = {:hosts => proxy["hosts"], :protocol => proxy["protocol"]}
-        expect(::Elasticsearch::Client).to have_received(:new) do |options|
-          expect(options[:transport_options][:proxy]).to eql(expected)
-        end
-      end
-    end
-  end
-
-  describe "invalid configs" do
-    let(:proxy) { ["bad", "stuff"] }
-
-    it "should have raised an exception" do
-      expect {
-        subject.register
-      }.to raise_error(LogStash::ConfigurationError)
-    end
-  end
-
-end