logstash-output-newrelic 1.3.0 → 1.5.0

data/spec/outputs/newrelic_spec.rb

@@ -4,6 +4,7 @@ require "logstash/outputs/newrelic"
 require "logstash/outputs/newrelic_version/version"
 require "logstash/codecs/plain"
 require "logstash/event"
+require "thread"
 require "webmock/rspec"
 require "zlib"
 
@@ -264,7 +265,7 @@ describe LogStash::Outputs::NewRelic do
     end
   end
 
-  context "error handling" do
+  context "error handling and retry logic" do
     it "continues through errors, future calls should still succeed" do
       stub_request(:any, base_uri)
         .to_raise(StandardError.new("from test"))
@@ -280,33 +281,41 @@ describe LogStash::Outputs::NewRelic do
         .to have_been_made
     end
 
-    it "retry when receive retryable http error code" do
-      stub_request(:any, base_uri)
-        .to_return(status: 500)
-        .to_return(status: 200)
-
-      event1 = LogStash::Event.new({ "message" => "Test message 1" })
-      @newrelic_output.multi_receive([event1])
-
-      wait_for(a_request(:post, base_uri)
-                 .with { |request| single_gzipped_message(request.body)['message'] == 'Test message 1' })
-        .to have_been_made.times(2)
+    [
+      { "returned_status_code" => 200, "expected_to_retry" => false },
+      { "returned_status_code" => 202, "expected_to_retry" => false },
+      { "returned_status_code" => 400, "expected_to_retry" => false },
+      { "returned_status_code" => 404, "expected_to_retry" => false },
+      { "returned_status_code" => 408, "expected_to_retry" => true },
+      { "returned_status_code" => 429, "expected_to_retry" => true },
+      { "returned_status_code" => 500, "expected_to_retry" => true },
+      { "returned_status_code" => 502, "expected_to_retry" => true },
+      { "returned_status_code" => 503, "expected_to_retry" => true },
+      { "returned_status_code" => 504, "expected_to_retry" => true },
+      { "returned_status_code" => 599, "expected_to_retry" => true }
+    ].each do |test_case|
+      returned_status_code = test_case["returned_status_code"]
+      expected_to_retry = test_case["expected_to_retry"]
+
+      it "should #{expected_to_retry ? "" : "not"} retry on status code #{returned_status_code}" do
+        stub_request(:any, base_uri)
+          .to_return(status: returned_status_code)
+          .to_return(status: 200)
+
+        logstash_event = LogStash::Event.new({ "message" => "Test message" })
+        @newrelic_output.multi_receive([logstash_event])
+
+        expected_retries = expected_to_retry ? 2 : 1
+        wait_for(a_request(:post, base_uri)
+                   .with { |request| single_gzipped_message(request.body)['message'] == 'Test message' })
+          .to have_been_made.at_least_times(expected_retries)
+        wait_for(a_request(:post, base_uri)
+                   .with { |request| single_gzipped_message(request.body)['message'] == 'Test message' })
+          .to have_been_made.at_most_times(expected_retries)
+      end
     end
 
-    it "not retry when receive a non retryable http error code" do
-      stub_request(:any, base_uri)
-        .to_return(status: 401)
-
-      event1 = LogStash::Event.new({ "message" => "Test message 1" })
-      @newrelic_output.multi_receive([event1])
-      # Due the async behavior we need to wait to be sure that the method was not called more than 1 time
-      sleep(2)
-      wait_for(a_request(:post, base_uri)
-                 .with { |request| single_gzipped_message(request.body)['message'] == 'Test message 1' })
-        .to have_been_made.times(1)
-    end
-
-    it "not retries when retry is disabled" do
+    it "does not retry when max_retries is set to 0" do
       @newrelic_output = LogStash::Plugin.lookup("output", "newrelic").new(
         { "base_uri" => base_uri, "license_key" => api_key, "max_retries" => '0' }
       )
@@ -323,7 +332,7 @@ describe LogStash::Outputs::NewRelic do
         .to have_been_made.times(1)
     end
 
-    it "retry when receive a not expected exception" do
+    it "retries when receive a not expected exception" do
       stub_request(:any, base_uri)
         .to_raise(StandardError.new("from test"))
         .to_return(status: 200)
@@ -379,4 +388,97 @@ describe LogStash::Outputs::NewRelic do
       ).to have_been_made
     end
   end
+
+  context "payload splitting" do
+
+    def stub_requests_and_capture_msg_ids(captured_msg_ids_accumulator)
+      mutex = Mutex.new
+      stub_request(:any, base_uri).to_return do |request|
+        mutex.synchronize do
+          captured_msg_ids_accumulator.concat(extract_msg_ids(request.body))
+        end
+        { status: 200 }
+      end
+    end
+
+    # Tests using this method expect log messages to contain a field "msgId" in their logs
+    def extract_msg_ids(body)
+      JSON.parse(gunzip(body))[0]['logs'].map do |log|
+        log['attributes']['msgId']
+      end
+    end
+
+    def expect_msg_ids(captured_msg_ids, msgIdsCount)
+      wait_for { captured_msg_ids.length }.to eq(msgIdsCount), "Expected a total of #{msgIdsCount} logs, but found #{captured_msg_ids.length}"
+      sorted_captured_msg_ids = captured_msg_ids.sort
+      for i in 0...msgIdsCount do
+        expect(sorted_captured_msg_ids[i]).to eq(i), "msgId #{i} not found"
+      end
+    end
+
+    it "splits logs into up to 1MB payloads" do
+      captured_msg_ids = []
+      stub_requests_and_capture_msg_ids(captured_msg_ids)
+
+      # This file contains 17997 random log record messages that upon compressed ends up being about 2.68MB
+      # Each log record is pretty small (no single log exceeds 1MB alone), so, we expect it to perform 4 requests to the API
+      # with
+      file_path = 'spec/outputs/input_17997_messages_resulting_in_2680KB_compressed_payload.json'
+
+      logstash_events =  File.readlines(file_path).map do |line|
+        LogStash::Event.new(JSON.parse(line))
+      end
+
+      @newrelic_output.multi_receive(logstash_events)
+
+      # Verify number of requests matches exactly 4. Note that .times() unexpectedly behaves as .at_least_times(), so we
+      # are forced to do this double verification to check the exact number of calls.
+      wait_for(a_request(:post, base_uri)).to have_been_made.at_least_times(4)
+      wait_for(a_request(:post, base_uri)).to have_been_made.at_most_times(4)
+
+      # Verify all expected msgIds were received
+      expect_msg_ids(captured_msg_ids, 17997)
+    end
+
+    it "does not split a log and does not perform any request if it exceeds 1MB once compressed" do
+      stub_request(:any, base_uri).to_return(status: 200)
+
+      # This file contains a SINGLE random log record that upon compressed ends up being about 1.8MB
+      # This payload cannot be further split, so we expect no call being made to the Logs API
+      file_path = 'spec/outputs/single_input_message_exceeeding_1MB_once_compressed.json'
+
+      logstash_events = []
+      File.foreach(file_path) do |line|
+        logstash_events << LogStash::Event.new(JSON.parse(line))
+      end
+
+      @newrelic_output.multi_receive(logstash_events)
+
+      wait_for(a_request(:post, base_uri)).not_to have_been_made
+    end
+
+    it "does a single request when the payload is below 1MB" do
+      captured_msg_ids = []
+      stub_requests_and_capture_msg_ids(captured_msg_ids)
+
+      # This file contains 5000 random log record messages that upon compressed ends up being about 0.74MB
+      # Given that this is below the 1MB allowed by the Logs API, a single request will be made
+      file_path = 'spec/outputs/input_5000_messages_resulting_in_740KB_compressed_payload.json'
+
+      logstash_events = []
+      File.foreach(file_path) do |line|
+        logstash_events << LogStash::Event.new(JSON.parse(line))
+      end
+
+      @newrelic_output.multi_receive(logstash_events)
+
+      # Verify number of requests matches exactly 1. Note that .times() unexpectedly behaves as .at_least_times(), so we
+      # are forced to do this double verification to check the exact number of calls.
+      wait_for(a_request(:post, base_uri)).to have_been_made.at_least_times(1)
+      wait_for(a_request(:post, base_uri)).to have_been_made.at_most_times(1)
+
+      # Verify all expected msgIds were received
+      expect_msg_ids(captured_msg_ids, 5000)
+    end
+  end
 end