logstash-output-sumologic 1.2.2 → 1.4.0

data/spec/outputs/sumologic/piler_spec.rb

@@ -1,9 +1,13 @@
 # encoding: utf-8
 require "logstash/devutils/rspec/spec_helper"
 require "logstash/outputs/sumologic"
+include LogStash::Outputs
 
-describe LogStash::Outputs::SumoLogic::Piler do
+describe SumoLogic::Piler do
   
+  event = LogStash::Event.new("foo" => "bar", "message" => "This is a log line")
+  event_10 = LogStash::Event.new("foo" => "bar", "message" => "1234567890")
+
   before :each do
     piler.start()
   end
@@ -15,9 +19,9 @@ describe LogStash::Outputs::SumoLogic::Piler do
 
   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) }
+    let(:stats) { SumoLogic::Statistics.new }
+    let(:queue) { SumoLogic::MessageQueue.new(stats, config) }
+    let(:piler) { SumoLogic::Piler.new(queue, stats, config) }
     specify {
       expect(piler.is_pile).to be true
     }
@@ -25,9 +29,9 @@ describe LogStash::Outputs::SumoLogic::Piler do
 
   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) }
+    let(:stats) { SumoLogic::Statistics.new }
+    let(:queue) { SumoLogic::MessageQueue.new(stats, config) }
+    let(:piler) { SumoLogic::Piler.new(queue, stats, config) }
     specify {
       expect(piler.is_pile).to be false
     }
@@ -35,152 +39,113 @@ describe LogStash::Outputs::SumoLogic::Piler do
 
   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) }
+    let(:stats) { SumoLogic::Statistics.new }
+    let(:queue) { SumoLogic::MessageQueue.new(stats, config) }
+    let(:piler) { 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) }
+    let(:config) { {"queue_max" => 10, "interval" => 0, "pile_max" => 100, "format" => "%{message}" } }
+    let(:stats) { SumoLogic::Statistics.new }
+    let(:queue) { SumoLogic::MessageQueue.new(stats, config) }
+    let(:piler) { 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
+      expect(stats.total_enque_times.value).to be 0
+      expect(queue.size).to be 0
+      piler.input(event)
+      expect(stats.total_enque_times.value).to be 1
+      expect(stats.total_enque_bytes.value).to be 18
+      expect(queue.size).to be 1
+      expect(queue.bytesize).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
+      piler.input(event)
+      expect(queue.deq().payload).to eq "This is a log line"
+      expect(queue.size).to be 0
+      expect(queue.bytesize).to be 0
       expect(stats.total_deque_times.value).to be 1
+      expect(stats.total_deque_bytes.value).to be 18
     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
+    let(:config) { {"queue_max" => 10, "interval" => 5, "pile_max" => 25, "format" => "%{message}" } }
+    let(:stats) { SumoLogic::Statistics.new }
+    let(:queue) { SumoLogic::MessageQueue.new(stats, config) }
+    let(:piler) { SumoLogic::Piler.new(queue, stats, config) }
 
     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
+      expect(queue.size).to be 0
+      piler.input(event_10)
+      expect(queue.size).to be 0
+      piler.input(event_10)
+      expect(queue.size).to be 0
+      piler.input(event_10)
+      expect(queue.size).to be 1
     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
+      expect(queue.size).to be 0
+      piler.input(event_10)
+      expect(queue.size).to be 0
+      piler.input(event_10)
+      sleep(10)
+      expect(queue.size).to be 1
     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
+    let(:config) { {"queue_max" => 5, "interval" => 3, "pile_max" => 5, "format" => "%{message}"} }
+    let(:stats) { SumoLogic::Statistics.new }
+    let(:queue) { SumoLogic::MessageQueue.new(stats, config) }
+    let(:piler) { SumoLogic::Piler.new(queue, stats, config) }
 
     it "block input thread if queue is full" do
       input_t = Thread.new {
-        for i in 0..9 do
-          piler.input("#{i}234567890")
+        for i in 0..10 do
+          piler.input(event_10)
         end
       }
       sleep(3)
-      expect(stats.current_queue_items.value).to be 5
-      expect(stats.current_queue_bytes.value).to be 50
-      queue.drain()
+      expect(queue.size).to be 5
+      expect(queue.bytesize).to be 50
       piler.stop()
-      input_t.join
-      expect(stats.total_deque_times.value).to be 5
-      expect(stats.total_deque_bytes.value).to be 50
+      queue.drain()
+      input_t.kill()
     end
 
     it "resume input thread if queue is drained" do
       input_t = Thread.new {
-        for i in 0..9 do
-          piler.input("#{i}234567890")
+        for i in 0..10 do
+          piler.input(event_10)
         end
       }
-      sleep(3)
+      sleep(5)
       expect(stats.total_deque_times.value).to be 0
+      expect(queue.size).to be 5
       expect(stats.total_enque_times.value).to be 5
       queue.deq()
-      sleep(1)
+      sleep(3)
       expect(stats.total_deque_times.value).to be 1
+      expect(queue.size).to be 5
       expect(stats.total_enque_times.value).to be 6
       queue.deq()
-      sleep(1)
+      sleep(3)
       expect(stats.total_deque_times.value).to be 2
+      expect(queue.size).to be 5
       expect(stats.total_enque_times.value).to be 7
-      queue.drain()
       piler.stop()
-      input_t.join
+      queue.drain()
+      input_t.kill()
     end
 
   end # context

data/spec/outputs/sumologic_spec.rb

@@ -13,6 +13,16 @@ describe LogStash::Outputs::SumoLogic, :unless => (ENV["sumo_url"].to_s.empty?)
     plugin.close()
   end
 
+  context "default configuration" do
+    let(:plugin) {
+      LogStash::Outputs::SumoLogic.new("url" => ENV["sumo_url"])
+    }
+    
+    it "cookies is by default disabled" do
+      expect(plugin.cookies).to be false
+    end
+  end
+  
   context "no pile" do
     context "single sender" do
       context "send log in json" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-output-sumologic
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.4.0
 platform: ruby
 authors:
 - Sumo Logic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-19 00:00:00.000000000 Z
+date: 2021-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: manticore
@@ -51,27 +51,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.99'
 - !ruby/object:Gem::Dependency
-  name: logstash-codec-plain
+  name: logstash-mixin-http_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
 - !ruby/object:Gem::Dependency
-  name: logstash-mixin-http_client
+  name: logstash-codec-plain
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -101,11 +107,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- DEVELOPER.md
+- CONTRIBUTING.md
 - Gemfile
 - LICENSE
 - README.md
 - lib/logstash/outputs/sumologic.rb
+- lib/logstash/outputs/sumologic/batch.rb
 - lib/logstash/outputs/sumologic/common.rb
 - lib/logstash/outputs/sumologic/compressor.rb
 - lib/logstash/outputs/sumologic/header_builder.rb
@@ -145,7 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.0
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Deliever the log to Sumo Logic cloud service.

data/DEVELOPER.md

@@ -1,39 +0,0 @@
-# Development Guide
-
-Logstash output plugin for delivering log to Sumo Logic cloud service through HTTP source.
-
-## How to build .gem file from repository
-
-Open logstash-output-sumologic.gemspec and make any necessary configuration changes.
-In your local Git clone, run:
-
-```bash
-gem build logstash-output-sumologic.gemspec
-```
-
-You will get a .gem file in the same directory as `logstash-output-sumologic-x.y.z.gem`
-Remove old version of plugin (optional):
-
-```bash
-bin/logstash-plugin remove logstash-output-sumologic
-```
-
-And then install the plugin locally:
-
-```bash
-bin/logstash-plugin install <full path of .gem>
-```
-
-## How to run test with rspec
-
-The test requires JRuby to run. So you need to install [JRuby](http://jruby.org/), [bundle](https://bundler.io/bundle_install.html) and [RVM](https://rvm.io/) (for switching between JRuby and Ruby) first.
-And then run:
-
-```bash
-rvm use jruby
-bundle install
-export sumo_url=https://events.sumologic.net/receiver/v1/http/XXXXXXXXXX
-rspec spec/
-```
-
-The project is integrated to the Travis CI now. Make sure [all test passed](https://travis-ci.org/SumoLogic/logstash-output-sumologic) before creating PR