logstash-output-newrelic 1.0.9 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0a73f938f33d3039ebcc6244256fbf7bce1b9c6e14e7f750a480c5296b6aeec
-  data.tar.gz: 7cb592d5293c3b8a40f77c56ed2a25b4e445f998caee48d5a402a55431c72a57
+  metadata.gz: 45a98fd90dd92f095b34d4593459e6b5587ab779c331597c291ea3b94ad4291e
+  data.tar.gz: f7f612da2d0040da95ca329c25e6dae097762246f5fa5061ad01082d22df0733
 SHA512:
-  metadata.gz: 67a8e4a292aea78322bda68fab079602819f5fc86222b49aff010abaa3b04f10195e5ce254a56a81d5524baf4c5c45629b9a78e1fc9c355992ff86d35240ef29
-  data.tar.gz: 248bcc51b955e3e2d7a54dd39dee5110cf61c3bc8853a079ef63a564bfa872a6739f610ba5ceb9aa21738e077c558aeb8b2573f2881013e3fdf8c1223fd57796
+  metadata.gz: 816c2f5fa309328ffdf78f58894885cf791c3f8fb91867620e8494e1761e2ca4b8d9744b4c6a385c13482a7654ecfc677fb0792dc4174141e0b92beb6bc757ec
+  data.tar.gz: b2b41b31f4af73a28bdad58416c10f0a25e54a56bc295987d96c825268bce4bcfcdc01e80ca0027dfaa71af95edb9c88d8fe254ad5be6aa6b025b692742d50b1

data/README.md

@@ -38,11 +38,13 @@ output {
 | Property | Description | Default value |
 |---|---|---|
 | concurrent_requests | The number of threads to make requests from | 1 |
-| retries | The maximum number of times to retry a failed request, exponentially increasing delay between each retry | 5 |
-| retry_seconds | The inital delay between retries, in seconds | 5 |
-| max_delay | The maximum delay between retries, in seconds | 30 |
 | base_uri | New Relic ingestion endpoint | https://log-api.newrelic.com/log/v1 |
 
+
+### EU plugin configuration
+
+When using this plugin in the EU override the base_uri with `http://log-api.eu.newrelic.com/log/v1`
+
 ## Testing
 
 An easy way to test the plugin is to make sure Logstash is getting input from a log file you 

data/lib/logstash/outputs/newrelic.rb

@@ -13,10 +13,8 @@ class LogStash::Outputs::NewRelic < LogStash::Outputs::Base
 
   config_name "newrelic"
 
-  config :api_key, :validate => :password, :required => true
-  config :retry_seconds, :validate => :number, :default => 5
-  config :max_delay, :validate => :number, :default => 30
-  config :retries, :validate => :number, :default => 5
+  config :api_key, :validate => :password, :required => false
+  config :license_key, :validate => :password, :required => false
   config :concurrent_requests, :validate => :number, :default => 1
   config :base_uri, :validate => :string, :default => "https://log-api.newrelic.com/log/v1"
 
@@ -24,11 +22,17 @@ class LogStash::Outputs::NewRelic < LogStash::Outputs::Base
 
   def register
     @end_point = URI.parse(@base_uri)
+    if @api_key.nil? && @license_key.nil?
+      raise LogStash::ConfigurationError, "Must provide a license key or api key", caller
+    end
+    auth = {
+      @api_key.nil? ? 'X-License-Key': 'X-Insert-Key' => 
+      @api_key.nil? ? @license_key.value : @api_key.value
+    }
     @header = {
-        'X-Insert-Key' => @api_key.value,
         'X-Event-Source' => 'logs',
         'Content-Encoding' => 'gzip'
-    }.freeze
+    }.merge(auth).freeze
     @executor = java.util.concurrent.Executors.newFixedThreadPool(@concurrent_requests)
     @semaphor = java.util.concurrent.Semaphore.new(@concurrent_requests)
   end
@@ -102,41 +106,19 @@ class LogStash::Outputs::NewRelic < LogStash::Outputs::Base
         gzip = Zlib::GzipWriter.new(io)
         gzip << [payload].to_json
         gzip.close
-        attempt_send(io.string, 0)
+        nr_send(io.string)
       ensure
         @semaphor.release()
       end
     end
   end
 
-  def should_retry?(attempt)
-    attempt < retries
-  end
-
-  def sleep_duration(attempt)
-    if attempt == 0
-      return 0
-    end
-
-    [max_delay, (2 ** (attempt - 1)) * retry_seconds].min
-  end
-
-  def sleep_on_retry(attempt)
-    duration = sleep_duration(attempt)
-    if duration > 0
-      sleep duration
+  def handle_response(response)
+    if !(200 <= response.code.to_i && response.code.to_i < 300)
+      @logger.error("Request returned " + response.code + " " + response.body)
     end
   end
 
-  def attempt_send(payload, attempt)
-    sleep_on_retry(attempt)
-    attempt_send(payload, attempt + 1) unless was_successful?(nr_send(payload)) if should_retry?(attempt)
-  end
-
-  def was_successful?(response)
-    200 <= response.code.to_i && response.code.to_i < 300
-  end
-
   def nr_send(payload)
     http = Net::HTTP.new(@end_point.host, 443)
     request = Net::HTTP::Post.new(@end_point.request_uri)
@@ -144,6 +126,6 @@ class LogStash::Outputs::NewRelic < LogStash::Outputs::Base
     http.verify_mode = OpenSSL::SSL::VERIFY_PEER
     @header.each {|k, v| request[k] = v}
     request.body = payload
-    http.request(request)
+    handle_response(http.request(request))
   end
 end # class LogStash::Outputs::NewRelic

data/lib/logstash/outputs/newrelic_version/version.rb

@@ -1,7 +1,7 @@
 module LogStash
   module Outputs
     module NewRelicVersion
-      VERSION = "1.0.9"
+      VERSION = "1.1.1"
     end
   end
 end

data/spec/outputs/newrelic_spec.rb

@@ -7,6 +7,48 @@ require "logstash/event"
 require "webmock/rspec"
 require "zlib"
 
+describe LogStash::Outputs::NewRelic do
+  let (:base_uri) { "https://testing-example-collector.com" }
+  let (:retry_seconds) { 0 }
+  # Don't sleep in tests, to keep tests fast. We have a test for the method that produces the sleep duration between retries.
+  let (:max_delay) { 0 }
+  let (:retries) { 3 }
+  let (:license_key) { 'cool-guy' }
+  let (:simple_config) {
+    {
+      "base_uri" => base_uri,
+      "license_key" => license_key
+    }
+  }
+
+
+  before(:each) do
+    @newrelic_output = LogStash::Plugin.lookup("output", "newrelic").new(simple_config)
+    @newrelic_output.register
+  end
+
+  after(:each) do
+    if @newrelic_output
+      @newrelic_output.shutdown
+    end
+  end
+  context "license key tests" do
+    it "sets license key when given in the header" do
+      stub_request(:any, base_uri).to_return(status: 200)
+
+      event = LogStash::Event.new({:message => "Test message" })
+      @newrelic_output.multi_receive([event])
+
+      wait_for(a_request(:post, base_uri)
+        .with(headers: {
+                "X-License-Key" => license_key,
+                "X-Event-Source" => "logs",
+                "Content-Encoding" => "gzip",
+              })).to have_been_made
+    end
+  end
+end
+
 describe LogStash::Outputs::NewRelic do
   let (:api_key) { "someAccountKey" }
   let (:base_uri) { "https://testing-example-collector.com" }
@@ -18,9 +60,6 @@ describe LogStash::Outputs::NewRelic do
     {
       "api_key" => api_key,
       "base_uri" => base_uri,
-      "retries" => retries,
-      "retry_seconds" => retry_seconds,
-      "max_delay" => max_delay,
     }
   }
 
@@ -71,8 +110,8 @@ describe LogStash::Outputs::NewRelic do
     it "requires api_key" do
       no_api_key_config = {
       }
-
-      expect { LogStash::Plugin.lookup("output", "newrelic").new(no_api_key_config) }.to raise_error LogStash::ConfigurationError
+      output =  LogStash::Plugin.lookup("output", "newrelic").new(no_api_key_config)
+      expect { output.register }.to raise_error LogStash::ConfigurationError
     end
   end
 
@@ -225,66 +264,6 @@ describe LogStash::Outputs::NewRelic do
     end
   end
 
-  context "retry" do
-    it "sleep periods double each time up to max time" do
-      specific_config = simple_config.clone
-      # Use non-trivial times -- they can be big, since this test doesn't do any sleeping, just
-      # tests the sleep duration
-      specific_config["max_delay"] = 60
-      specific_config["retry_seconds"] = 5
-
-      # Create a new plugin with this specific config that has longer retry sleep
-      # configuration than we normally want
-      @newrelic_output.shutdown
-      @newrelic_output = LogStash::Plugin.lookup("output", "newrelic").new(specific_config)
-      @newrelic_output.register
-
-      expect(@newrelic_output.sleep_duration(0)).to equal(0)
-      expect(@newrelic_output.sleep_duration(1)).to equal(5)
-      expect(@newrelic_output.sleep_duration(2)).to equal(10)
-      expect(@newrelic_output.sleep_duration(3)).to equal(20)
-      expect(@newrelic_output.sleep_duration(4)).to equal(40)
-      expect(@newrelic_output.sleep_duration(5)).to equal(60)
-      expect(@newrelic_output.sleep_duration(6)).to equal(60) # Never gets bigger than this
-    end
-
-    it "first call fails, should retry" do
-      stub_request(:any, base_uri)
-        .to_return(status: 500)
-        .to_return(status: 200)
-
-      event = LogStash::Event.new({ "message" => "Test message" })
-      @newrelic_output.multi_receive([event])
-
-      wait_for(a_request(:post, base_uri)).to have_been_made.times(2)
-    end
-
-    it "first two calls fail, should retry" do
-      stub_request(:any, base_uri)
-        .to_return(status: 500)
-        .to_return(status: 500)
-        .to_return(status: 200)
-
-      event = LogStash::Event.new({ "message" => "Test message" })
-      @newrelic_output.multi_receive([event])
-
-      wait_for(a_request(:post, base_uri)).to have_been_made.times(3)
-    end
-
-    it "all calls fails, should stop retrying at some point" do
-      stub_request(:any, base_uri)
-        .to_return(status: 500)
-
-      event = LogStash::Event.new({ "message" => "Test message" })
-      @newrelic_output.multi_receive([event])
-
-      # This may not fail if the wait_for is called exactly when there have been 'retries' calls.
-      # However, with zero sleep time (max_delay=0), on a laptop the POST was done 2000+ times by the
-      # time this was executed
-      wait_for(a_request(:post, base_uri)).to have_been_made.times(retries)
-    end
-  end
-
   context "error handling" do
     it "continues through errors, future calls should still succeed" do
       stub_request(:any, base_uri)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-output-newrelic
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 1.1.1
 platform: ruby
 authors:
 - New Relic Logging Team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-08-23 00:00:00.000000000 Z
+date: 2019-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement