logstash-output-newrelic 1.0.9 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0a73f938f33d3039ebcc6244256fbf7bce1b9c6e14e7f750a480c5296b6aeec
-  data.tar.gz: 7cb592d5293c3b8a40f77c56ed2a25b4e445f998caee48d5a402a55431c72a57
+  metadata.gz: fb4f741e9437b23b81a902b6817268ce3f4e149d903bc52f46bd95ce37faf488
+  data.tar.gz: dc73e88716eb0586d919dfdc42aba8376dbf1827318ffb0eda693434962f3cb8
 SHA512:
-  metadata.gz: 67a8e4a292aea78322bda68fab079602819f5fc86222b49aff010abaa3b04f10195e5ce254a56a81d5524baf4c5c45629b9a78e1fc9c355992ff86d35240ef29
-  data.tar.gz: 248bcc51b955e3e2d7a54dd39dee5110cf61c3bc8853a079ef63a564bfa872a6739f610ba5ceb9aa21738e077c558aeb8b2573f2881013e3fdf8c1223fd57796
+  metadata.gz: d3ddca2bb8715a311dfe7532781266c80bc84f0d9663997053a86a82088b7329b0cafb45d573bc71f6b955c80af353a75182a6d18ba949d0f86884af1022cba1
+  data.tar.gz: 91345ad4fb85d4d767d56486a5e48452fdb7008d4f855a4953da60d16ebb91f50265befbffd43b0170ecffadc475ae3a468479f3c0c4222be9c43cfc174f8f95

data/DEVELOPER.md

@@ -14,14 +14,6 @@
 * Run tests: `jruby -S bundle exec rspec`
 * Build the gem: `jruby -S gem build logstash-output-newrelic.gemspec`
 
-## Pushing changes to the public repo
-After updating the New Relic repo with changes, changes will need to be pushed to the public GitHub repo at: https://github.com/newrelic/logstash-output-plugin
-
-* `git remote add public git@github.com:newrelic/logstash-output-plugin.git`
-* `git push public master:name-of-branch-to-create`
-* Create a PR from that branch in https://github.com/newrelic/logstash-output-plugin
-* Get the PR reviewed, merged, and delete the branch!
-
 # Testing it with a local Logstash install
 
 Note: you may need to run the following commands outside of your checkout, since these should not
@@ -31,10 +23,4 @@ be run with the JRuby version that you've configured your checkout to use (by us
 * Add new version: `logstash-plugin install logstash-output-newrelic-<version>.gem`
 * Restart logstash: For Homebrew: `brew services restart logstash`
 * Cause a change that you've configured Logstash to pick up (for instance, append to a file you're having it monitor)
-* Look in `https://staging-one.newrelic.com/launcher/logger.log-launcher` for your log message
-
-# Push changes to RubyGems
-After updating the source code and gem version in `version.rb`, push the changes to RubyGems. There is an older version of the gem that we do not want to overwrite — `version 0.9.1`. Please be sure you are publishing changes to the correct gem i.e. `version 1.0.0` or higher. Note, you must be a gem owner to publish changes on [RubyGems.org](https://rubygems.org/profiles/NR-LOGGING). Once you've created the account, you will need to run `gem signin` to login to RubyGems via the command line.
-
-* Build the gem: `gem build logstash-output-newrelic.gemspec`
-* Publish the gem: `gem push logstash-output-newrelic-<VERSION>.gem` with the updated version (ex: `gem push logstash-output-newrelic-1.0.0.gem`)
+* Look in `https://one.newrelic.com/launcher/logger.log-launcher` for your log message

data/README.md

@@ -11,9 +11,11 @@ Versions of this plugin less than 1.0.0 are unsupported.
 
 ## Configuration
 
-Add the following block to your logstash.conf (with your specific API Insert key), then restart Logstash.
+Add one of the following blocks to your logstash.conf (with your specific key), then restart Logstash.
 There are other optional configuration properties, see below.
 
+### Using API Insert Key
+
 Get your API Insert Key:
 `https://insights.newrelic.com/accounts/<ACCOUNT_ID>/manage/api_keys`
 
@@ -26,22 +28,40 @@ output {
 }
 ```
 
+### Using License Key
+
+Get your License Key:
+`https://rpm.newrelic.com/accounts/<ACCOUNT_ID>`
+
+Example:
+```rb
+output {
+  newrelic {
+    license_key => "<LICENSE_KEY>"
+  }
+}
+```
 
 ### Required plugin configuration
 
+Exactly one of the following:
+
 | Property | Description |
 |---|---|
 | api_key | your New Relic API Insert key |
+| license_key | your New Relic License key |
 
 ### Optional plugin configuration
 
 | 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 |
+| max_retries | Maximum number attempts to retry to send a message. If set to 0, no re-attempts will be made. | 3 |
+
+### EU plugin configuration
+
+When using this plugin in the EU override the base_uri with `https://log-api.eu.newrelic.com/log/v1`
 
 ## Testing
 
@@ -57,30 +77,3 @@ input {
 * Restart Logstash
 * Append a test log message to your log file: `echo "test message" >> /path/to/your/log/file`
 * Search New Relic Logs for `"test message"`
-
-## JSON message parsing
-
-This plugin will attempt to parse any 'message' attribute as JSON -- if it is JSON, it will be parsed and 
-the JSON attributes will be added to the event.
-
-For example, the event:
-```
-{
-  "timestamp": 1562767499238,
-  "message": "{\"service-name\": \"login-service\", \"user\": {\"id\": 123, \"name\": \"alice\"}}"
-}
-
-```
-
-Will be treated as:
-```
-{
-  "timestamp": 1562767499238,
-  "message": "{\"service-name\": \"my-service\", \"user\": {\"id\": 123, \"name\": \"alice\"}}",
-  "service-name": "login-service",
-  "user": {
-    "id": 123,
-    "name": "alice"
-  }
-}
-```

data/lib/logstash/outputs/config/bigdecimal_patch.rb

@@ -0,0 +1,24 @@
+require 'bigdecimal'
+
+class BigDecimal
+    # Floating-point numbers that go through the 'json' Logstash filter get automatically converted into BigDecimals.
+    # Example of such a filter:
+    #
+    # filter {
+    #   json {
+    #     source => "message"
+    #   }
+    # }
+    #
+    # The problem is that { "value" => BigDecimal('0.12345') } gets serialized into { "value": "0.12345e0"}. We do
+    # want to keep floating point numbers serialized as floating point numbers, even at the expense of loosing a little
+    # bit of precision during the conversion. So, in the above example, the correct serialization would be:
+    # { "value": 0.12345}
+    def to_json(options = nil) #:nodoc:
+      if finite?
+        self.to_f.to_s
+      else
+        'null'
+      end
+    end
+  end

data/lib/logstash/outputs/exception/error.rb

@@ -0,0 +1,14 @@
+class Error
+  class BadResponseCodeError < StandardError
+    attr_reader :url, :response_code
+
+    def initialize(response_code, url)
+      @response_code = response_code
+      @url = url
+    end
+
+    def message
+      "Got response code '#{@response_code}' contacting NewRelic at URL '#{@url}'"
+    end
+  end
+end

data/lib/logstash/outputs/newrelic.rb

@@ -6,29 +6,39 @@ require 'uri'
 require 'zlib'
 require 'json'
 require 'java'
+require 'set'
+require_relative './config/bigdecimal_patch'
+require_relative './exception/error'
 
 class LogStash::Outputs::NewRelic < LogStash::Outputs::Base
   java_import java.util.concurrent.Executors;
   java_import java.util.concurrent.Semaphore;
 
+  NON_RETRYABLE_CODES = Set[401, 403]
+
   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"
+  config :max_retries, :validate => :number, :default => 3
 
   public
 
   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
+      'X-Event-Source' => 'logs',
+      'Content-Encoding' => 'gzip'
+    }.merge(auth).freeze
     @executor = java.util.concurrent.Executors.newFixedThreadPool(@concurrent_requests)
     @semaphor = java.util.concurrent.Semaphore.new(@concurrent_requests)
   end
@@ -54,11 +64,10 @@ class LogStash::Outputs::NewRelic < LogStash::Outputs::Base
     end
   end
 
-
   def encode(event_hash)
     log_message_hash = {
-        # non-intrinsic attributes get put into 'attributes'
-        :attributes => event_hash
+      # non-intrinsic attributes get put into 'attributes'
+      :attributes => event_hash
     }
 
     # intrinsic attributes go at the top level
@@ -84,15 +93,15 @@ class LogStash::Outputs::NewRelic < LogStash::Outputs::Base
       payload.push(encode(event.to_hash))
     end
     payload = {
-        :common => {
-            :attributes => {
-                :plugin => {
-                    :type => 'logstash',
-                    :version => LogStash::Outputs::NewRelicVersion::VERSION,
-                }
-            }
-        },
-        :logs => payload
+      :common => {
+        :attributes => {
+          :plugin => {
+            :type => 'logstash',
+            :version => LogStash::Outputs::NewRelicVersion::VERSION,
+          }
+        }
+      },
+      :logs => payload
     }
     @semaphor.acquire()
     execute = @executor.java_method :submit, [java.lang.Runnable]
@@ -102,48 +111,59 @@ 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
+  def handle_response(response)
+    if !(200 <= response.code.to_i && response.code.to_i < 300)
+      raise Error::BadResponseCodeError.new(response.code.to_i, @base_uri)
     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 nr_send(payload)
+    retries = 0
+    begin
+      http = Net::HTTP.new(@end_point.host, 443)
+      request = Net::HTTP::Post.new(@end_point.request_uri)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      @header.each { |k, v| request[k] = v }
+      request.body = payload
+      handle_response(http.request(request))
+    rescue Error::BadResponseCodeError => e
+      @logger.error(e.message)
+      if (should_retry(retries) && is_retryable_code(e))
+        retries += 1
+        sleep(1)
+        retry
+      end
+    rescue => e
+      # Stuff that should never happen
+      # For all other errors print out full issues
+      @logger.error(
+        "An unknown error occurred sending a bulk request to NewRelic.",
+        :error_message => e.message,
+        :error_class => e.class.name,
+        :backtrace => e.backtrace
+      )
+      if (should_retry(retries))
+        retries += 1
+        sleep(1)
+        retry
+      end
     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)
+  def should_retry(retries)
+    retries < @max_retries
   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)
-    http.use_ssl = true
-    http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-    @header.each {|k, v| request[k] = v}
-    request.body = payload
-    http.request(request)
+  def is_retryable_code(response_error)
+    error_code = response_error.response_code
+    !NON_RETRYABLE_CODES.include?(error_code)
   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.2.0"
     end
   end
 end

data/logstash-output-newrelic.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "logstash-codec-plain"
   s.add_development_dependency "logstash-devutils"
   s.add_development_dependency "webmock"
+  s.add_development_dependency "rspec"
   s.add_development_dependency "rspec-wait"
-
+  s.add_development_dependency "rspec_junit_formatter"
 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,80 +264,119 @@ 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
+  context "error handling" do
+    it "continues through errors, future calls should still succeed" do
+      stub_request(:any, base_uri)
+        .to_raise(StandardError.new("from test"))
+        .to_return(status: 200)
 
-      # 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
+      event1 = LogStash::Event.new({ "message" => "Test message 1" })
+      event2 = LogStash::Event.new({ "message" => "Test message 2" })
+      @newrelic_output.multi_receive([event1])
+      @newrelic_output.multi_receive([event2])
 
-      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
+      wait_for(a_request(:post, base_uri)
+        .with { |request| single_gzipped_message(request.body)['message'] == 'Test message 2' })
+        .to have_been_made
     end
 
-    it "first call fails, should retry" do
+    it "retry when receive retryable http error code" 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])
+      event1 = LogStash::Event.new({ "message" => "Test message 1" })
+      @newrelic_output.multi_receive([event1])
 
-      wait_for(a_request(:post, base_uri)).to have_been_made.times(2)
+      wait_for(a_request(:post, base_uri)
+                 .with { |request| single_gzipped_message(request.body)['message'] == 'Test message 1' })
+        .to have_been_made.times(2)
     end
 
-    it "first two calls fail, should retry" do
+    it "not retry when receive a non retryable http error code" do
       stub_request(:any, base_uri)
-        .to_return(status: 500)
-        .to_return(status: 500)
-        .to_return(status: 200)
+        .to_return(status: 401)
 
-      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)
+      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 "all calls fails, should stop retrying at some point" do
+    it "not retries when retry is disabled" do
+      @newrelic_output = LogStash::Plugin.lookup("output", "newrelic").new(
+        { "base_uri" => base_uri, "license_key" => api_key, "max_retries" => '0' }
+      )
+      @newrelic_output.register
       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)
+      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
-  end
 
-  context "error handling" do
-    it "continues through errors, future calls should still succeed" do
+    it "retry when receive a not expected exception" do
       stub_request(:any, base_uri)
         .to_raise(StandardError.new("from test"))
         .to_return(status: 200)
 
       event1 = LogStash::Event.new({ "message" => "Test message 1" })
-      event2 = LogStash::Event.new({ "message" => "Test message 2" })
       @newrelic_output.multi_receive([event1])
-      @newrelic_output.multi_receive([event2])
+      wait_for(a_request(:post, base_uri)
+                 .with { |request| single_gzipped_message(request.body)['message'] == 'Test message 1' })
+        .to have_been_made.times(2)
+    end
+  end
+
+  context "JSON serialization" do
+    it "serializes floating point numbers as floating point numbers" do
+      stub_request(:any, base_uri).to_return(status: 200)
+
+      event = LogStash::Event.new({ "floatingpoint" => 0.12345 })
+      @newrelic_output.multi_receive([event])
 
       wait_for(a_request(:post, base_uri)
-        .with { |request| single_gzipped_message(request.body)['message'] == 'Test message 2' })
-        .to have_been_made
+        .with { |request|
+          message = single_gzipped_message(request.body)
+          message['attributes']['floatingpoint'] == 0.12345
+        }
+      ).to have_been_made
+    end
+
+    it "serializes BigDecimals as floating point numbers" do
+      stub_request(:any, base_uri).to_return(status: 200)
+
+      event = LogStash::Event.new({ "bigdecimal" => BigDecimal('0.12345') })
+      @newrelic_output.multi_receive([event])
+
+      wait_for(a_request(:post, base_uri)
+        .with { |request|
+          message = single_gzipped_message(request.body)
+          message['attributes']['bigdecimal'] == 0.12345
+        }
+      ).to have_been_made
+    end
+
+    it "serializes NaN as null" do
+      stub_request(:any, base_uri).to_return(status: 200)
+
+      event = LogStash::Event.new({ "nan" => BigDecimal('NaN') })
+      @newrelic_output.multi_receive([event])
+
+      wait_for(a_request(:post, base_uri)
+        .with { |request|
+          message = single_gzipped_message(request.body)
+          message['attributes']['nan'] == nil
+        }
+      ).to have_been_made
     end
   end
 end