logstash-output-sumologic 1.1.4 → 1.1.9

data/spec/outputs/sumologic/piler_spec.rb

@@ -0,0 +1,189 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/outputs/sumologic"
+
+describe LogStash::Outputs::SumoLogic::Piler do
+  
+  before :each do
+    piler.start()
+  end
+
+  after :each do
+    queue.drain()
+    piler.stop()
+  end
+
+  context "working in pile mode if interval > 0 && pile_max > 0" do
+    let(:config) { {"queue_max" => 10, "interval" => 10, "pile_max" => 100 } }
+    let(:stats) { LogStash::Outputs::SumoLogic::Statistics.new() }
+    let(:queue) { LogStash::Outputs::SumoLogic::MessageQueue.new(stats, config) }
+    let(:piler) { LogStash::Outputs::SumoLogic::Piler.new(queue, stats, config) }
+    specify {
+      expect(piler.is_pile).to be true
+    }
+  end # context
+
+  context "working in non-pile mode if interval <= 0" do
+    let(:config) { {"queue_max" => 10, "interval" => 0, "pile_max" => 100 } }
+    let(:stats) { LogStash::Outputs::SumoLogic::Statistics.new() }
+    let(:queue) { LogStash::Outputs::SumoLogic::MessageQueue.new(stats, config) }
+    let(:piler) { LogStash::Outputs::SumoLogic::Piler.new(queue, stats, config) }
+    specify {
+      expect(piler.is_pile).to be false
+    }
+  end # context
+
+  context "working in non-pile mode if pile_max <= 0" do
+    let(:config) { {"queue_max" => 10, "interval" => 10, "pile_max" => 0 } }
+    let(:stats) { LogStash::Outputs::SumoLogic::Statistics.new() }
+    let(:queue) { LogStash::Outputs::SumoLogic::MessageQueue.new(stats, config) }
+    let(:piler) { LogStash::Outputs::SumoLogic::Piler.new(queue, stats, config) }
+    specify {
+      expect(piler.is_pile).to be false
+    }
+  end # context
+
+  context "in non-pile mode" do
+
+    let(:config) { {"queue_max" => 10, "interval" => 0, "pile_max" => 100 } }
+    let(:stats) { LogStash::Outputs::SumoLogic::Statistics.new() }
+    let(:queue) { LogStash::Outputs::SumoLogic::MessageQueue.new(stats, config) }
+    let(:piler) { LogStash::Outputs::SumoLogic::Piler.new(queue, stats, config) }
+
+    it "enque immediately after input" do
+      expect(stats.current_pile_items.value).to be 0
+      expect(stats.current_queue_items.value).to be 0
+      piler.input("This is a log line")
+      expect(stats.current_pile_items.value).to be 0
+      expect(stats.current_queue_items.value).to be 1
+      expect(stats.current_queue_bytes.value).to be 18
+    end
+
+    it "deque correctly" do
+      expect(stats.current_queue_items.value).to be 0
+      expect(stats.total_enque_times.value).to be 0
+      piler.input("This is a log line")
+      expect(stats.total_enque_times.value).to be 1
+      expect(stats.current_queue_items.value).to be 1
+      expect(stats.current_queue_bytes.value).to be 18
+      expect(stats.total_deque_times.value).to be 0
+      expect(queue.deq()).to eq "This is a log line"
+      expect(stats.current_queue_items.value).to be 0
+      expect(stats.current_queue_bytes.value).to be 0
+      expect(stats.total_deque_times.value).to be 1
+    end
+
+  end # context
+
+  context "in pile mode" do
+
+    let(:config) { {"queue_max" => 10, "interval" => 5, "pile_max" => 25 } }
+    let(:stats) { LogStash::Outputs::SumoLogic::Statistics.new() }
+    let(:queue) { LogStash::Outputs::SumoLogic::MessageQueue.new(stats, config) }
+    let(:piler) { LogStash::Outputs::SumoLogic::Piler.new(queue, stats, config) }
+
+    it "wait in pile before size reach pile_max" do
+      expect(stats.current_pile_items.value).to be 0
+      expect(stats.current_pile_bytes.value).to be 0
+      expect(stats.current_queue_items.value).to be 0
+      piler.input("1234567890")
+      expect(stats.current_pile_items.value).to be 1
+      expect(stats.current_pile_bytes.value).to be 10
+      expect(stats.current_queue_items.value).to be 0
+      piler.input("1234567890")
+      expect(stats.current_pile_items.value).to be 2
+      expect(stats.current_pile_bytes.value).to be 20
+      expect(stats.current_queue_items.value).to be 0
+    end
+
+    it "enqueue content from pile when reach pile_max" do
+      expect(stats.current_pile_items.value).to be 0
+      expect(stats.current_pile_bytes.value).to be 0
+      expect(stats.current_queue_items.value).to be 0
+      piler.input("1234567890")
+      piler.input("1234567890")
+      expect(stats.current_queue_items.value).to be 0
+      piler.input("1234567890")
+      expect(stats.current_pile_items.value).to be 1
+      expect(stats.current_pile_bytes.value).to be 10
+      expect(stats.current_queue_items.value).to be 1
+      expect(stats.current_queue_bytes.value).to be 21
+    end
+
+    it "enqueue content from pile when reach interval" do
+      expect(stats.current_pile_items.value).to be 0
+      expect(stats.current_pile_bytes.value).to be 0
+      piler.input("1234567890")
+      piler.input("1234567890")
+      expect(stats.current_queue_items.value).to be 0
+      sleep(8)
+      expect(stats.current_pile_items.value).to be 0
+      expect(stats.current_pile_bytes.value).to be 0
+      expect(stats.current_queue_items.value).to be 1
+      expect(stats.current_queue_bytes.value).to be 21
+    end
+
+  end # context
+
+  context "pile to message queue" do
+
+    let(:config) { {"queue_max" => 5, "interval" => 500, "pile_max" => 5} }
+    let(:stats) { LogStash::Outputs::SumoLogic::Statistics.new() }
+    let(:queue) { LogStash::Outputs::SumoLogic::MessageQueue.new(stats, config) }
+    let(:piler) { LogStash::Outputs::SumoLogic::Piler.new(queue, stats, config) }
+
+    it "enqueue payloads from pile before reach queue_max" do
+      expect(stats.current_queue_items.value).to be 0
+      piler.input("1234567890")
+      expect(stats.current_queue_items.value).to be 0
+      expect(stats.current_queue_bytes.value).to be 0
+      piler.input("2234567890")
+      expect(stats.current_queue_items.value).to be 1
+      expect(stats.current_queue_bytes.value).to be 10
+      piler.input("3234567890")
+      expect(stats.current_queue_items.value).to be 2
+      expect(stats.current_queue_bytes.value).to be 20
+    end
+
+    it "block input thread if queue is full" do
+      input_t = Thread.new {
+        for i in 0..9 do
+          piler.input("#{i}234567890")
+        end
+      }
+      sleep(3)
+      expect(stats.current_queue_items.value).to be 5
+      expect(stats.current_queue_bytes.value).to be 50
+      queue.drain()
+      piler.stop()
+      input_t.join
+      expect(stats.total_deque_times.value).to be 5
+      expect(stats.total_deque_bytes.value).to be 50
+    end
+
+    it "resume input thread if queue is drained" do
+      input_t = Thread.new {
+        for i in 0..9 do
+          piler.input("#{i}234567890")
+        end
+      }
+      sleep(3)
+      expect(stats.total_deque_times.value).to be 0
+      expect(stats.total_enque_times.value).to be 5
+      queue.deq()
+      sleep(1)
+      expect(stats.total_deque_times.value).to be 1
+      expect(stats.total_enque_times.value).to be 6
+      queue.deq()
+      sleep(1)
+      expect(stats.total_deque_times.value).to be 2
+      expect(stats.total_enque_times.value).to be 7
+      queue.drain()
+      piler.stop()
+      input_t.join
+    end
+
+  end # context
+
+end # describe
+

data/spec/outputs/sumologic/sender_spec.rb

@@ -0,0 +1,188 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "rspec/eventually"
+require "logstash/outputs/sumologic"
+
+require_relative "../../test_server.rb"
+
+describe LogStash::Outputs::SumoLogic::Sender do
+
+  before :all do
+    @@server = TestServer.new()
+    @@server.start()
+  end
+
+  before :each do
+    @@server.response = TestServer::RESPONSE_200
+    @@server.drain()
+  end
+
+  after :all do
+    @@server.stop()
+  end
+
+  context "connect()" do
+    let(:stats) { LogStash::Outputs::SumoLogic::Statistics.new() }
+    let(:queue) { LogStash::Outputs::SumoLogic::MessageQueue.new(stats, "queue_max" => 10) }
+    let(:sender) { LogStash::Outputs::SumoLogic::Sender.new(false, queue, stats, "url" => "http://localhost:#{TestServer::PORT}") }
+
+    it "should return true if sever response 200" do
+      expect(sender.connect()).to be true
+      result = @@server.drain()
+      expect(result.size).to eq(1)
+    end
+
+    it "should return false if sever response 429" do
+      @@server.response = TestServer::RESPONSE_429
+      expect(sender.connect()).to be false
+      result = @@server.drain()
+      expect(result.size).to eq(1)
+    end
+
+    it "should return false if sever cannot reach" do
+      sender = LogStash::Outputs::SumoLogic::Sender.new(false, queue, stats, "url" => "http://localhost:#{TestServer::PORT + 1}")
+      expect(sender.connect()).to be false
+      result = @@server.drain()
+      expect(result.size).to eq(0)
+    end
+
+  end # context
+
+  context "single sender" do
+    let(:plugin) { LogStash::Outputs::SumoLogic.new("url" => "http://localhost:#{TestServer::PORT}", "sender_max" => 1, "sleep_before_requeue" => 1, "request_timeout" => 3) }
+    let(:event) { LogStash::Event.new("host" => "myHost", "message" => "Hello world") }
+
+    it "should send message correctly" do
+      plugin.register
+      plugin.receive(event)
+      expect { plugin.stats.total_output_requests.value }.to eventually(eq(1)).pause_for(1)
+      expect { plugin.stats.total_response("200") }.to eventually(eq(1)).pause_for(1)
+      result = @@server.drain()
+      expect(result.size).to eq(2)
+      plugin.receive(event)
+      expect { plugin.stats.total_output_requests.value }.to eventually(eq(2)).pause_for(1)
+      expect { plugin.stats.total_response("200") }.to eventually(eq(2)).pause_for(1)
+      result = @@server.drain()
+      expect(result.size).to eq(1)
+    end
+
+    it "should re-enque the message if got 429" do
+      plugin.register
+      plugin.receive(event)
+      expect { plugin.stats.total_output_requests.value }.to eventually(eq(1)).pause_for(1)
+      expect { plugin.stats.total_response("200") }.to eventually(eq(1)).pause_for(1)
+      result = @@server.drain()
+      expect(result.size).to eq(2)
+      @@server.response = TestServer::RESPONSE_429
+      plugin.receive(event)
+      expect { plugin.stats.total_output_requests.value }.to eventually(be > 1).within(10).pause_for(1)
+      expect { plugin.stats.total_response("429") }.to eventually(be > 1).within(10).pause_for(1)
+      result = @@server.drain()
+      expect(result.size).to be > 0
+      @@server.response = TestServer::RESPONSE_200
+      expect { plugin.stats.total_response("200") }.to eventually(be > 1).within(10).pause_for(1)
+      result = @@server.drain()
+      expect(result.size).to be > 0
+    end
+
+    it "should re-enque the message if network failed" do
+      plugin.register
+      plugin.receive(event)
+      expect { plugin.stats.total_output_requests.value }.to eventually(eq(1)).pause_for(1)
+      expect { plugin.stats.total_response("200") }.to eventually(eq(1)).pause_for(1)
+      result = @@server.drain()
+      expect(result.size).to eq(2)
+      @@server.stop()
+      plugin.receive(event)
+      expect { plugin.stats.total_output_requests.value }.to eventually(be > 1).within(10).pause_for(1)
+      expect { plugin.stats.total_response("failure") }.to eventually(be > 1).within(25).pause_for(1)
+      result = @@server.drain()
+      @@server.start()
+      @@server.response = TestServer::RESPONSE_200
+      expect { plugin.stats.total_response("200") }.to eventually(be > 1).within(10).pause_for(1)
+      result = @@server.drain()
+      expect(result.size).to be > 0
+    end
+
+  end # context
+
+  context "multiple senders" do
+    let(:plugin) { LogStash::Outputs::SumoLogic.new("url" => "http://localhost:#{TestServer::PORT}", "sender_max" => 10, "sleep_before_requeue" => 1, "request_timeout" => 3) }
+    let(:event) { LogStash::Event.new("host" => "myHost", "message" => "Hello world") }
+
+    it "should send message correctly" do
+      plugin.register
+      plugin.receive(event)
+      expect { plugin.stats.total_output_requests.value }.to eventually(eq(1)).pause_for(1)
+      expect { plugin.stats.total_response("200") }.to eventually(eq(1)).pause_for(1)
+      result = @@server.drain()
+      expect(result.size).to eq(2)
+      plugin.receive(event)
+      expect { plugin.stats.total_output_requests.value }.to eventually(eq(2)).pause_for(1)
+      expect { plugin.stats.total_response("200") }.to eventually(eq(2)).pause_for(1)
+      result = @@server.drain()
+      expect(result.size).to eq(1)
+    end
+
+    it "should re-enque the message if got 429" do
+      plugin.register
+      plugin.receive(event)
+      expect { plugin.stats.total_output_requests.value }.to eventually(eq(1)).pause_for(1)
+      expect { plugin.stats.total_response("200") }.to eventually(eq(1)).pause_for(1)
+      result = @@server.drain()
+      expect(result.size).to eq(2)
+      @@server.response = TestServer::RESPONSE_429
+      plugin.receive(event)
+      expect { plugin.stats.total_output_requests.value }.to eventually(be > 1).within(10).pause_for(1)
+      expect { plugin.stats.total_response("429") }.to eventually(be > 1).within(10).pause_for(1)
+      result = @@server.drain()
+      expect(result.size).to be > 0
+      @@server.response = TestServer::RESPONSE_200
+      expect { plugin.stats.total_response("200") }.to eventually(be > 1).within(10).pause_for(1)
+      result = @@server.drain()
+      expect(result.size).to be > 0
+    end
+    
+    it "should re-enque the message if network failed" do
+      plugin.register
+      plugin.receive(event)
+      expect { plugin.stats.total_output_requests.value }.to eventually(eq(1)).pause_for(1)
+      expect { plugin.stats.total_response("200") }.to eventually(eq(1)).pause_for(1)
+      result = @@server.drain()
+      expect(result.size).to eq(2)
+      @@server.stop()
+      plugin.receive(event)
+      expect { plugin.stats.total_output_requests.value }.to eventually(be > 1).within(10).pause_for(1)
+      expect { plugin.stats.total_response("failure") }.to eventually(be > 1).within(25).pause_for(1)
+      result = @@server.drain()
+      @@server.start()
+      @@server.response = TestServer::RESPONSE_200
+      expect { plugin.stats.total_response("200") }.to eventually(be > 1).within(10).pause_for(1)
+      result = @@server.drain()
+      expect(result.size).to be > 0
+    end
+
+    it "should reuse tokens" do
+      plugin.register
+      30.times { plugin.receive(event) }
+      expect { plugin.stats.total_response("200") }.to eventually(eq 30).within(100).pause_for(1)
+    end
+
+  end # context
+
+  context "close()" do
+
+    let(:plugin) { LogStash::Outputs::SumoLogic.new("url" => "http://localhost:#{TestServer::PORT}", "sender_max" => 10) }
+    let(:event) { LogStash::Event.new("host" => "myHost", "message" => "Hello world") }
+
+    it "should drain out messages" do
+      plugin.register
+      30.times { plugin.receive(event) }
+      plugin.close
+      expect(plugin.stats.total_response("200")).to eq 30
+    end
+
+  end # context
+
+end # describe
+

data/spec/outputs/sumologic_spec.rb

@@ -1,406 +1,230 @@
-
 # encoding: utf-8
 require "logstash/devutils/rspec/spec_helper"
+require "rspec/eventually"
 require "logstash/outputs/sumologic"
-require "logstash/event"
-
-require_relative '../spec_helper'
 
-describe LogStash::Outputs::SumoLogic do
+describe LogStash::Outputs::SumoLogic, :unless => (ENV["sumo_url"].to_s.empty?) do
 
-  let(:server) { subject.server }
-  
   before :each do
-    subject.register
-    subject.receive(event)
-  end
-
-  # For log
-  context "log sent in default format" do
-
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234") }
-    let(:event) { LogStash::Event.new("host" => "myHost", "message" => "Hello world") }
-
-    it "generate one element" do
-      expect(server.size).to eq(1)
-    end
-
-    it "include all content" do
-      expect(server.pop).to include("myHost Hello world")
-    end
-
-  end
-
-  context "log sent as @json" do
-
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", "format" => "%{@json}") }
-    let(:event) { LogStash::Event.new("host" => "myHost", "message" => "Hello world") }
-
-    it "generate one element" do
-      expect(server.size).to eq(1)
-    end
-
-    it "include all content" do
-      received = server.pop
-      expect(received).to include("\"host\":\"myHost\"")
-      expect(received).to include("\"message\":\"Hello world\"")
-    end
-
-  end
-
-  context "log sent in customized format" do
-
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", "format" => "%{foo} %{bar}" ) }
-    let(:event) { LogStash::Event.new("host" => "myHost", "foo" => "fancy", "bar" => 24) }
-
-    it "generate one element" do
-      expect(server.size).to eq(1)
-    end
-
-    it "include all content" do
-      expect(server.pop).to eq("fancy 24")
-    end
-
-  end
-
-  context "log sent with customized json_mapping" do
-
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", 
-					       "format" => "%{host} %{@json}", 
-					       "json_mapping" => { "foo" => "%{foo}", "bar" => "%{bar}", "%{foo}" => "%{bar}" } ) }
-    let(:event) { LogStash::Event.new("host" => "myHost", "foo" => "fancy", "bar" => 24) }
-
-    it "generate one element" do
-      expect(server.size).to eq(1)
-    end
-
-    it "include all content" do
-      expect(server.pop).to eq("myHost {\"foo\":\"fancy\",\"bar\":\"24\",\"fancy\":\"24\"}")
-    end
-
-  end
-
-  # For headers
-  context "check default headers" do
-
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234") }
-    let(:event) { LogStash::Event.new("host" => "myHost", "message" => "Hello world") }
-
-    it "check header" do
-      expect(server.header).to eq({"X-Sumo-Host"=>`hostname`.strip, "X-Sumo-Client"=>"logstash-output-sumologic", "Content-Type"=>"text/plain"})
-    end
-
-  end
-
-  context "override source_category" do
-    
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", "source_category" => "my source category") }
-    let(:event) { LogStash::Event.new("host" => "myHost", "message" => "Hello world") }
-
-    it "check header" do
-      expect(server.header).to eq({"X-Sumo-Host"=>`hostname`.strip, 
-				   "X-Sumo-Client"=>"logstash-output-sumologic", 
-				   "Content-Type"=>"text/plain", 
-				   "X-Sumo-Category"=>"my source category"})
-    end
-
-  end
-
-  context "override source_name" do
-    
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", "source_name" => "my source name") }
-    let(:event) { LogStash::Event.new("host" => "myHost", "message" => "Hello world") }
-
-    it "check header" do
-      expect(server.header).to eq({"X-Sumo-Host"=>`hostname`.strip, 
-				   "X-Sumo-Client"=>"logstash-output-sumologic", 
-				   "Content-Type"=>"text/plain", 
-				   "X-Sumo-Name"=>"my source name"})
-    end
-
-  end
-
-  context "override source_host" do
-    
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", "source_host" => "my source host") }
-    let(:event) { LogStash::Event.new("host" => "myHost", "message" => "Hello world") }
-
-    it "check header" do
-      expect(server.header).to eq({"X-Sumo-Host"=>"my source host", "X-Sumo-Client"=>"logstash-output-sumologic", "Content-Type"=>"text/plain"})
-    end
-
-  end
-
-  context "with extra_headers" do
-    
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", "extra_headers" => {"foo" => "bar"}) }
-    let(:event) { LogStash::Event.new("host" => "myHost", "message" => "Hello world") }
-
-    it "check header" do
-      expect(server.header).to eq({"X-Sumo-Host"=>`hostname`.strip, "X-Sumo-Client"=>"logstash-output-sumologic", "Content-Type"=>"text/plain", "foo"=>"bar"})
-    end
-
-  end
-
-  context "with compress" do
-    
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", "compress" => true) }
-    let(:event) { LogStash::Event.new("host" => "myHost", "message" => "Hello world") }
-
-    it "check header" do
-      expect(server.header).to eq({"X-Sumo-Host"=>`hostname`.strip, 
-				   "X-Sumo-Client"=>"logstash-output-sumologic", 
-				   "Content-Type"=>"text/plain", 
-				   "Content-Encoding"=>"deflate"})
-    end
-
-  end
-
-  context "with gzip" do
-    
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", "compress" => true, "compress_encoding"=>"gzip") }
-    let(:event) { LogStash::Event.new("host" => "myHost", "message" => "Hello world") }
-
-    it "check header" do
-      expect(server.header).to eq({"X-Sumo-Host"=>`hostname`.strip, 
-				   "X-Sumo-Client"=>"logstash-output-sumologic", 
-				   "Content-Type"=>"text/plain", 
-				   "Content-Encoding"=>"gzip"})
-    end
-
-  end
-
-  # For metrics
-  context "with metrics sent in graphite" do
-
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", 
-					       "metrics" => { "hurray.%{foo}" => "%{bar}"}, 
-					       "metrics_format" => "graphite") }
-    let(:event) { LogStash::Event.new("host" => "myHost", "foo" => "fancy", "bar" => 24) }
-
-    it "generate one element" do
-      expect(server.size).to eq(1)
-    end
-
-    it "check header" do
-      expect(server.header).to eq({"X-Sumo-Host"=>`hostname`.strip, 
-				   "X-Sumo-Client"=>"logstash-output-sumologic", 
-				   "Content-Type"=>"application/vnd.sumologic.graphite"})
-    end
-
-    it "include all content" do
-      expect(server.pop).to match(/^hurray.fancy 24 \d{10,}$/)
-    end
-
-  end
-
-  context "with metrics sent in carbon2" do
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", "metrics" => { "hurray.%{foo}" => "%{bar}" }) }
-    let(:event) { LogStash::Event.new("host" => "myHost", "foo" => "fancy", "bar" => 24) }
-
-    it "generate one element" do
-      expect(server.size).to eq(1)
-    end
-
-    it "check header" do
-      expect(server.header).to eq({"X-Sumo-Host"=>`hostname`.strip, 
-				   "X-Sumo-Client"=>"logstash-output-sumologic", 
-				   "Content-Type"=>"application/vnd.sumologic.carbon2"})
-    end
-
-    it "include all content" do
-      expect(server.pop).to match(/^metric=hurray.fancy  24 \d{10,}$/)
-    end
-  end
-
-  context "with metrics_name override" do
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", 
-					       "metrics" => { "hurray.%{foo}" => "%{bar}" }, 
-					       "metrics_name" => "mynamespace.*") }
-    let(:event) { LogStash::Event.new("host" => "myHost", "foo" => "fancy", "bar" => 24) }
-
-    it "include all content" do
-      expect(server.pop).to match(/^metric=mynamespace.hurray.fancy  24 \d{10,}$/)
-    end
-  end
-
-  context "with intrinsic_tags override" do
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", 
-					       "metrics" => { "bar" => "%{bar}" }, 
-					       "intrinsic_tags" => {"host"=>"%{host}"}) }
-    let(:event) { LogStash::Event.new("host" => "myHost", "foo" => "fancy", "bar" => 24) }
-
-    it "include all content" do
-      expect(server.pop).to match(/^host=myHost metric=bar  24 \d{10,}$/)
-    end
-  end
-
-  context "with meta_tags override" do
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", 
-					       "metrics" => { "bar" => "%{bar}" }, 
-					       "intrinsic_tags" => {"host"=>"%{host}"}, 
-					       "meta_tags" => {"foo" => "%{foo}"}) }
-    let(:event) { LogStash::Event.new("host" => "myHost", "foo" => "fancy", "bar" => 24) }
-
-    it "include all content" do
-      expect(server.pop).to match(/^host=myHost metric=bar  foo=fancy 24 \d{10,}$/)
-    end
-  end
-
-  context "with multiple metrics mapping" do
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", 
-					       "metrics" => { "cpu1" => "%{cpu1}", "cpu2" => "%{cpu2}" }, 
-					       "intrinsic_tags" => {"host"=>"%{host}"}, 
-					       "meta_tags" => {"foo" => "%{foo}"}) }
-    let(:event) { LogStash::Event.new("host" => "myHost", "foo" => "fancy", "cpu1" => 0.24, "cpu2" => 0.11) }
-
-    it "include content" do
-      sorted = server.all_sorted
-      expect(sorted.pop).to match(/^host=myHost metric=cpu1  foo=fancy 0\.24 \d{10,}$/)
-      expect(sorted.pop).to match(/^host=myHost metric=cpu2  foo=fancy 0\.11 \d{10,}$/)
-    end
-  end
-
-  context "metrics with non-number value should be dropped (carbon2)" do
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", 
-					       "metrics" => { "cpu1" => "%{cpu1}", "cpu2" => "%{cpu2}", "cpu3" => "%{cpu3}" }, 
-					       "intrinsic_tags" => {"host"=>"%{host}"}, "meta_tags" => {"foo" => "%{foo}"}) }
-    let(:event) { LogStash::Event.new("host" => "myHost", "foo" => "fancy", "cpu1" => 0.24, "cpu2" => "abc", "cpu3" => 0.11) }
-
-    it "include content" do
-      sorted = server.all_sorted
-      expect(sorted.pop).to match(/^host=myHost metric=cpu1  foo=fancy 0\.24 \d{10,}$/)
-      expect(sorted.pop).to match(/^host=myHost metric=cpu3  foo=fancy 0\.11 \d{10,}$/)
-      expect(sorted.empty?).to eq(true)
-    end
-  end
-
-  context "metrics with non-number value should be dropped (graphite)" do
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", 
-					       "metrics" => { "cpu1" => "%{cpu1}", "cpu2" => "%{cpu2}", "cpu3" => "%{cpu3}" }, 
-					       "metrics_format" => "graphite") }
-    let(:event) { LogStash::Event.new("host" => "myHost", "foo" => "fancy", "cpu1" => 0.24, "cpu2" => "abc", "cpu3" => 0.11) }
-
-    it "include content" do
-      sorted = server.all_sorted
-      expect(sorted.pop).to match(/^cpu1 0\.24 \d{10,}$/)
-      expect(sorted.pop).to match(/^cpu3 0\.11 \d{10,}$/)
-      expect(sorted.empty?).to eq(true)
-    end
-  end
-
-  context "fields_as_metrics (carbon2)" do
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", 
-					       "fields_as_metrics" => true, 
-					       "intrinsic_tags" => {"host"=>"%{host}"}, 
-					       "meta_tags" => {"foo" => "%{foo}"}) }
-    let(:event) { LogStash::Event.new(
-      "host" => "myHost", 
-      "foo" => "fancy", 
-      "cpu" => [0.24, 0.11, 0.75, 0.28], 
-      "storageRW" => 51, 
-      "bar" => "blahblah", 
-      "blkio" => {
-        "write_ps" => 5,
-        "read_ps" => 2,
-        "total_ps" => 0
-      })}
-
-    it "include content" do
-      sorted = server.all_sorted
-      expect(sorted.pop).to match(/^host=myHost metric=blkio\.read_ps  foo=fancy 2 \d{10,}$/)
-      expect(sorted.pop).to match(/^host=myHost metric=blkio\.total_ps  foo=fancy 0 \d{10,}$/)
-      expect(sorted.pop).to match(/^host=myHost metric=blkio\.write_ps  foo=fancy 5 \d{10,}$/)
-      expect(sorted.pop).to match(/^host=myHost metric=cpu\.0  foo=fancy 0\.24 \d{10,}$/)
-      expect(sorted.pop).to match(/^host=myHost metric=cpu\.1  foo=fancy 0\.11 \d{10,}$/)
-      expect(sorted.pop).to match(/^host=myHost metric=cpu\.2  foo=fancy 0\.75 \d{10,}$/)
-      expect(sorted.pop).to match(/^host=myHost metric=cpu\.3  foo=fancy 0\.28 \d{10,}$/)
-      expect(sorted.pop).to match(/^host=myHost metric=storageRW  foo=fancy 51 \d{10,}$/)
-      expect(sorted.empty?).to eq(true)
-    end
-  end
-
-  context "fields_as_metrics (graphite)" do
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", "fields_as_metrics" => true, "metrics_format" => "graphite") }
-    let(:event) { LogStash::Event.new(
-      "host" => "myHost", 
-      "foo" => "fancy", 
-      "cpu" => [0.24, 0.11, 0.75, 0.28], 
-      "storageRW" => 51, 
-      "bar" => "blahblah", 
-      "blkio" => {
-        "write_ps" => 0,
-        "read_ps" => 0,
-        "total_ps" => 0
-      })}
-
-    it "include content" do
-      sorted = server.all_sorted
-      expect(sorted.pop).to match(/^blkio\.read_ps 0 \d{10,}$/)
-      expect(sorted.pop).to match(/^blkio\.total_ps 0 \d{10,}$/)
-      expect(sorted.pop).to match(/^blkio\.write_ps 0 \d{10,}$/)
-      expect(sorted.pop).to match(/^cpu\.0 0\.24 \d{10,}$/)
-      expect(sorted.pop).to match(/^cpu\.1 0\.11 \d{10,}$/)
-      expect(sorted.pop).to match(/^cpu\.2 0\.75 \d{10,}$/)
-      expect(sorted.pop).to match(/^cpu\.3 0\.28 \d{10,}$/)
-      expect(sorted.pop).to match(/^storageRW 51 \d{10,}$/)
-    end
-  end
-
-  context "fields_include is honored when fields_as_metrics (carbon2)" do
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", 
-					       "fields_as_metrics" => true, 
-					       "intrinsic_tags" => {"host"=>"%{host}"}, 
-					       "meta_tags" => {"foo" => "%{foo}"}, 
-					       "fields_include" => ["cpu*"]) }
-    let(:event) { LogStash::Event.new(
-      "host" => "myHost", 
-      "foo" => "fancy", 
-      "cpu" => [0.24, 0.11, 0.75, 0.28], 
-      "storageRW" => 51, 
-      "bar" => "blahblah", 
-      "blkio" => {
-        "write_ps" => 5,
-        "read_ps" => 2,
-        "total_ps" => 0
-      })}
-
-    it "include content" do
-      sorted = server.all_sorted
-      expect(sorted.pop).to match(/^host=myHost metric=cpu\.0  foo=fancy 0\.24 \d{10,}$/)
-      expect(sorted.pop).to match(/^host=myHost metric=cpu\.1  foo=fancy 0\.11 \d{10,}$/)
-      expect(sorted.pop).to match(/^host=myHost metric=cpu\.2  foo=fancy 0\.75 \d{10,}$/)
-      expect(sorted.pop).to match(/^host=myHost metric=cpu\.3  foo=fancy 0\.28 \d{10,}$/)
-      expect(sorted.empty?).to eq(true)
-    end
-  end
-
-  context "fields_exclude is honored when fields_as_metrics (carbon2)" do
-    subject { LogStash::Outputs::SumoLogic.new("url" => "http://localhost/1234", 
-					       "fields_as_metrics" => true, 
-					       "intrinsic_tags" => {"host"=>"%{host}"}, 
-					       "meta_tags" => {"foo" => "%{foo}"}, 
-					       "fields_include" => ["cpu*"], 
-					       "fields_exclude" => [".*1"]) }
-    let(:event) { LogStash::Event.new(
-      "host" => "myHost", 
-      "foo" => "fancy", 
-      "cpu" => [0.24, 0.11, 0.75, 0.28], 
-      "storageRW" => 51, 
-      "bar" => "blahblah", 
-      "blkio" => {
-        "write_ps" => 5,
-        "read_ps" => 2,
-        "total_ps" => 0
-      })}
-
-    it "include content" do
-      sorted = server.all_sorted
-      expect(sorted.pop).to match(/^host=myHost metric=cpu\.0  foo=fancy 0\.24 \d{10,}$/)
-      expect(sorted.pop).to match(/^host=myHost metric=cpu\.2  foo=fancy 0\.75 \d{10,}$/)
-      expect(sorted.pop).to match(/^host=myHost metric=cpu\.3  foo=fancy 0\.28 \d{10,}$/)
-      expect(sorted.empty?).to eq(true)
-    end
-  end
-
-end
+    plugin.register()
+  end
+
+  after :each do
+    plugin.close()
+  end
+
+  context "no pile" do
+    context "single sender" do
+      context "send log in json" do
+        let(:plugin) { 
+          LogStash::Outputs::SumoLogic.new(
+            "url" => ENV["sumo_url"], 
+            "sender_max" => 1,
+            "format" => "%{@json}")
+        }
+        specify {
+          event = LogStash::Event.new("host" => "myHost", "message" => "Hello world")
+          plugin.receive(event)
+          expect { plugin.stats.total_output_requests.value }.to eventually(be > 0).within(10).pause_for(1)
+          expect { plugin.stats.total_response("200") }.to eventually(be > 0).within(10).pause_for(1)
+        }
+      end
+      context "send fields as metrics" do
+        let(:plugin) { 
+          LogStash::Outputs::SumoLogic.new(
+            "url" => ENV["sumo_url"],
+            "sender_max" => 1,
+            "fields_as_metrics" => true,
+            "intrinsic_tags" => {
+              "host"=>"%{host}"
+            },
+            "meta_tags" => {
+              "foo" => "%{foo}"
+            })
+        }
+
+        specify {
+          event = LogStash::Event.new(
+            "host" => "myHost",
+            "foo" => "fancy",
+            "cpu" => [0.24, 0.11, 0.75, 0.28],
+            "storageRW" => 51,
+            "bar" => "blahblah",
+            "blkio" => {
+              "write_ps" => 5,
+              "read_ps" => 2,
+              "total_ps" => 0
+            })
+          
+          plugin.receive(event)
+          expect { plugin.stats.total_output_requests.value }.to eventually(be > 0).within(10).pause_for(1)
+          expect { plugin.stats.total_response("200") }.to eventually(be > 0).within(10).pause_for(1)
+        }
+      end
+    end
+    context "multiple senders" do
+      context "send log in json" do
+        let(:plugin) {
+          LogStash::Outputs::SumoLogic.new(
+            "url" => ENV["sumo_url"], 
+            "sender_max" => 5,
+            "format" => "%{@json}")
+        }
+        
+        specify {
+          5.times { |t| 
+            event = LogStash::Event.new("host" => "myHost", "message" => "Hello world - #{t}")
+            plugin.receive(event)
+          } 
+          expect { plugin.stats.total_output_requests.value }.to eventually(be > 0).within(10).pause_for(1)
+          expect { plugin.stats.total_response("200") }.to eventually(be > 0).within(10).pause_for(1)
+        }
+      end
+
+      context "send multiple log in json" do
+        let(:plugin) {
+          LogStash::Outputs::SumoLogic.new(
+            "url" => ENV["sumo_url"], 
+            "sender_max" => 5,
+            "format" => "%{@json}"
+          )
+        }
+        
+        specify {
+          5.times { |t| 
+            events = 10.times.map { |r|
+              LogStash::Event.new("host" => "myHost", "message" => "Hello world - #{t} - #{r}")
+            }
+            plugin.multi_receive(events)
+          } 
+          expect { plugin.stats.total_output_requests.value }.to eventually(be > 0).within(10).pause_for(1)
+          expect { plugin.stats.total_response("200") }.to eventually(be > 0).within(10).pause_for(1)
+        }
+      end
+    end
+  end
+  context "has pile" do
+    context "single sender" do
+      context "send log in json" do
+        let(:plugin) {
+          LogStash::Outputs::SumoLogic.new(
+            "url" => ENV["sumo_url"], 
+            "sender_max" => 1,
+            "interval" => 3,
+            "format" => "%{@json}")
+        }
+        
+        specify {
+          5.times { |t| 
+            event = LogStash::Event.new("host" => "myHost", "message" => "Hello world - #{t}")
+            plugin.receive(event)
+          } 
+          expect { plugin.stats.total_output_requests.value }.to eventually(be > 0).within(10).pause_for(1)
+          expect { plugin.stats.total_response("200") }.to eventually(be > 0).within(10).pause_for(1)
+        }
+      end
+
+      context "send multiple log in json" do
+        let(:plugin) {
+          LogStash::Outputs::SumoLogic.new(
+            "url" => ENV["sumo_url"], 
+            "sender_max" => 1,
+            "interval" => 3,
+            "format" => "%{@json}"
+          )
+        }
+        
+        specify {
+          5.times { |t| 
+            events = 10.times.map { |r|
+              LogStash::Event.new("host" => "myHost", "message" => "Hello world - #{t} - #{r}")
+            }
+            plugin.multi_receive(events)
+          } 
+          expect { plugin.stats.total_output_requests.value }.to eventually(be > 0).within(10).pause_for(1)
+          expect { plugin.stats.total_response("200") }.to eventually(be > 0).within(10).pause_for(1)
+        }
+      end
+    end
+    context "multi senders" do
+      context "send log in json" do
+        
+        let(:plugin) {
+          LogStash::Outputs::SumoLogic.new(
+            "url" => ENV["sumo_url"], 
+            "sender_max" => 5,
+            "interval" => 3,
+            "format" => "%{@json}")
+        }
+        
+        specify {
+          5.times { |t| 
+            event = LogStash::Event.new("host" => "myHost", "message" => "Hello world - #{t}")
+            plugin.receive(event)
+          } 
+          expect { plugin.stats.total_output_requests.value }.to eventually(be > 0).within(10).pause_for(1)
+          expect { plugin.stats.total_response("200") }.to eventually(be > 0).within(10).pause_for(1)
+        }
+      end
+      context "send multiple log in json" do
+        let(:plugin) {
+          LogStash::Outputs::SumoLogic.new(
+            "url" => ENV["sumo_url"], 
+            "sender_max" => 5,
+            "interval" => 3,
+            "format" => "%{@json}"
+          )
+        }
+        
+        specify {
+          5.times { |t| 
+            events = 10.times.map { |r|
+              LogStash::Event.new("host" => "myHost", "message" => "Hello world - #{t} - #{r}")
+            }
+            plugin.multi_receive(events)
+          } 
+          expect { plugin.stats.total_output_requests.value }.to eventually(be > 0).within(10).pause_for(1)
+          expect { plugin.stats.total_response("200") }.to eventually(be > 0).within(10).pause_for(1)
+        }
+      end
+    end
+  end
+
+  @@map = [('a'..'z'), ('A'..'Z')].map(&:to_a).flatten
+  def get_line(length)
+    length.times.map { @@map[rand(@@map.length)] }.join
+  end
+
+  context "throughput baseline" do
+    let(:plugin) {
+      LogStash::Outputs::SumoLogic.new(
+        "url" => ENV["sumo_url"], 
+        "source_category" => "logstash_ci_baseline",
+        "sender_max" => 100,
+        "interval" => 30,
+        "format" => "%{@timestamp} %{message}",
+        "compress" => true,
+        "compress_encoding" => "gzip",
+        "stats_enabled" => true,
+        "stats_interval" => 1
+      )
+    }
+
+    log_length = 5000 + rand(1000)
+    log_count = 50000 + rand(10000)
+  
+    specify {
+      log_count.times { |t| 
+        event = LogStash::Event.new("message" => "#{t} - #{get_line(log_length)}")
+        plugin.receive(event)
+      } 
+      expect { plugin.stats.total_log_lines.value }.to eventually(be >= log_count).within(60).pause_for(1)
+      bytes = plugin.stats.total_output_bytes.value
+      spend = (Time.now - plugin.stats.initialize_time) * 1000
+      rate = bytes / spend * 1000
+      puts "Sent #{plugin.stats.total_log_lines.value} log lines with #{bytes} bytes in #{'%.2f' % spend} ms, rate #{'%.2f' % (rate/1024/1024) } MB/s."
+      expect(rate).to be > 2_000_000
+    }
+  end
+
+end # describe