logstash-output-dynatrace 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fa581d24c7d6dea1eed2199562913047b8712dc6f1c0c1259c7621880605552
-  data.tar.gz: 6ade6b59b77d436cbc9a537ce3fd87ca39345c243bd61bf927514c12d50f3246
+  metadata.gz: 74790f2358ebc0f61dbc88da2c1af0beed1ac35a3a0f021a18e1d365e7751e3a
+  data.tar.gz: 4d8cbb3c59a4bd6224457f49c25f01932686662551c7642f6fc65047663413e7
 SHA512:
-  metadata.gz: 3b03743e665c6af4ae1bf6be5031884aa71cc5dc1d27744d7229ce8bf5ccedd6e56097816bf73548492196a2bf484af9bbd5be41bcaca982c915a634a60af161
-  data.tar.gz: f7621c4ca998dca1166f73927ac58dc585c71036dd70af2d59ae8640c7aa4661eaf9ba64a4632127449d3d4e494c35321f25f5fdab110d6bbcbb9ac0395fcc33
+  metadata.gz: 2f970e3aa82cb27219224b241c3b30d3e0c5e3a6a70cec220ce3d7952507ab9a7a1d5c207f22602385871baee310ec3fe3b291c1f8e486462656d5c75b60cbf1
+  data.tar.gz: dd03de995d2038dfcf533fa050b6ceb16dd627a5e3258c95528e96eaf4b345efacb92f3cc81e922c3af604732f4ed532342e245bc0e1d74d4a3592394746ec50

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## 0.2.0
+ - Add retries with exponential backoff (#8)
+
+## 0.1.0
+ - Initial release

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/logstash/outputs/dynatrace.rb

@@ -18,16 +18,19 @@ require 'logstash/namespace'
 require 'logstash/outputs/base'
 require 'logstash/json'
 
+MAX_RETRIES = 5
+
 module LogStash
   module Outputs
+    class RetryableError < StandardError;
+    end
+
     # An output which sends logs to the Dynatrace log ingest v2 endpoint formatted as JSON
     class Dynatrace < LogStash::Outputs::Base
       @plugin_version = ::File.read(::File.expand_path('../../../VERSION', __dir__)).strip
 
       config_name 'dynatrace'
 
-      concurrency :single
-
       # The full URL of the Dynatrace log ingestion endpoint:
       # - on SaaS:    https://{your-environment-id}.live.dynatrace.com/api/v2/logs/ingest
       # - on Managed: https://{your-domain}/e/{your-environment-id}/api/v2/logs/ingest
@@ -41,7 +44,7 @@ module LogStash
 
       default :codec, 'json'
 
-      attr_accessor :uri
+      attr_accessor :uri, :plugin_version
 
       def register
         require 'net/https'
@@ -56,11 +59,6 @@ module LogStash
         @logger.info('Client', client: @client.inspect)
       end
 
-      # This is split into a separate method mostly to help testing
-      def log_failure(message, opts)
-        @logger.error(message, opts)
-      end
-
       def headers
         {
           'User-Agent' => "logstash-output-dynatrace v#{@plugin_version}",
@@ -73,12 +71,44 @@ module LogStash
       def multi_receive(events)
         return if events.length.zero?
 
-        request = Net::HTTP::Post.new(uri, headers)
-        request.body = "#{LogStash::Json.dump(events.map(&:to_hash)).chomp}\n"
-        response = @client.request(request)
-        return if response.is_a? Net::HTTPSuccess
+        retries = 0
+        begin
+          request = Net::HTTP::Post.new(uri, headers)
+          request.body = "#{LogStash::Json.dump(events.map(&:to_hash)).chomp}\n"
+          response = send(request)
+          return if response.is_a? Net::HTTPSuccess
+
+          failure_message = "Dynatrace returned #{response.code} #{response.message}."
+
+          if response.is_a? Net::HTTPServerError
+            raise RetryableError.new failure_message
+          end
+
+          if response.is_a? Net::HTTPNotFound
+            @logger.error("#{failure_message} Please check that log ingest is enabled and your API token has the `logs.ingest` (Ingest Logs) scope.")
+            return
+          end
+
+          if response.is_a? Net::HTTPClientError
+            @logger.error(failure_message)
+            return
+          end
+        rescue Net::HTTPBadResponse, RetryableError => e
+          # indicates a protocol error
+          if retries < MAX_RETRIES  
+            sleep_seconds = 2 ** retries
+            @logger.warn("Failed to contact dynatrace: #{e.message}. Trying again after #{sleep_seconds} seconds.")
+            sleep sleep_seconds
+            retries += 1
+            retry
+          else
+            @logger.error("Failed to export logs to Dynatrace.")
+          end
+        end
+      end
 
-        log_failure('Bad Response', request: request.inspect, response: response.inspect)
+      def send(request)
+        @client.request(request)
       end
     end
   end

data/spec/outputs/dynatrace_spec.rb

@@ -19,133 +19,109 @@ require 'logstash/codecs/plain'
 require 'logstash/event'
 require 'sinatra'
 require 'insist'
-
-PORT = rand(65_535 - 1024) + 1025
-
-# NOTE: that Sinatra startup and shutdown messages are directly logged to stderr so
-# it is not really possible to disable them without reopening stderr which is not advisable.
-#
-# == Sinatra (v1.4.6) has taken the stage on 51572 for development with backup from WEBrick
-# == Sinatra has ended his set (crowd applauds)
-#
-class TestApp < Sinatra::Base
-  # disable WEBrick logging
-  def self.server_settings
-    { AccessLog: [], Logger: WEBrick::BasicLog.new(nil, WEBrick::BasicLog::FATAL) }
-  end
-
-  class << self
-    attr_accessor :last_request
-
-    def clear
-      self.last_request = nil
-    end
-  end
-
-  post '/good' do
-    self.class.last_request = request
-    [204, '']
-  end
-
-  post '/bad' do
-    self.class.last_request = request
-    [400, 'Bad']
-  end
-end
-
-RSpec.configure do |config|
-  # http://stackoverflow.com/questions/6557079/start-and-call-ruby-http-server-in-the-same-script
-  def sinatra_run_wait(app, opts)
-    queue = Queue.new
-
-    t = java.lang.Thread.new(
-      proc do
-        begin
-          app.run!(opts) do |_server|
-            queue.push('started')
-          end
-        rescue StandardError => e
-          puts "Error in webserver thread #{e}"
-          # ignore
-        end
-      end
-    )
-    t.daemon = true
-    t.start
-    queue.pop # blocks until the run! callback runs
-  end
-
-  config.before(:suite) do
-    sinatra_run_wait(TestApp, port: PORT, server: 'webrick')
-    puts "Test webserver on port #{PORT}"
-  end
-end
+require 'net/http'
+require 'json'
 
 describe LogStash::Outputs::Dynatrace do
-  let(:port) { PORT }
-  let(:event) do
-    LogStash::Event.new({ 'message' => 'hi' })
+  let(:events) do
+    [
+      LogStash::Event.new({ 'message' => 'message 1', '@timestamp' => "2021-06-25T15:46:45.693Z" }),
+      LogStash::Event.new({ 'message' => 'message 2', '@timestamp' => "2021-06-25T15:46:46.693Z" }),
+    ]
   end
-  let(:url) { "http://localhost:#{port}/good" }
+  let(:url) { "http://localhost/good" }
   let(:key) { 'api.key' }
   let(:subject) { LogStash::Outputs::Dynatrace.new({ 'api_key' => key, 'ingest_endpoint_url' => url }) }
 
   before do
     subject.register
-    allow(subject).to receive(:log_failure).with(any_args)
+    subject.plugin_version = "1.2.3"
   end
 
-  context 'sending no events' do
-    it 'does not crash on empty events' do
-      subject.multi_receive([])
-    end
+  it 'does not send empty events' do
+    allow(subject).to receive(:send)
+    subject.multi_receive([])
+    expect(subject).to_not have_received(:send)
   end
 
-  context 'with passing requests' do
-    before do
-      TestApp.clear
-      subject.multi_receive([event])
+  context 'server response success' do
+    it 'sends events' do
+      allow(subject).to receive(:send) do |req|
+        body = JSON.parse(req.body)
+        expect(body.length).to eql(2)
+        expect(body[0]['message']).to eql('message 1')
+        expect(body[0]['@timestamp']).to eql('2021-06-25T15:46:45.693Z')
+        expect(body[1]['message']).to eql('message 2')
+        expect(body[1]['@timestamp']).to eql('2021-06-25T15:46:46.693Z')
+        Net::HTTPOK.new "1.1", "200", "OK"
+      end
+      subject.multi_receive(events)
+      expect(subject).to have_received(:send)
     end
 
-    let(:last_request) { TestApp.last_request }
-    let(:body) { last_request.body.read }
-    let(:content_type) { last_request.env['CONTENT_TYPE'] }
-    let(:authorization) { last_request.env['HTTP_AUTHORIZATION'] }
-
-    let(:expected_body) { "#{LogStash::Json.dump([event])}\n" }
-    let(:expected_content_type) { 'application/json; charset=utf-8' }
-    let(:expected_authorization) { "Api-Token #{key}" }
-
-    it 'should not log a failure' do
-      expect(subject).not_to have_received(:log_failure).with(any_args)
+    it 'includes authorization header' do
+      allow(subject).to receive(:send) do |req|
+        expect(req['Authorization']).to eql("Api-Token #{key}")
+        Net::HTTPOK.new "1.1", "200", "OK"
+      end
+      subject.multi_receive(events)
+      expect(subject).to have_received(:send)
     end
 
-    it 'should receive the request' do
-      expect(last_request).to be_truthy
+    it 'includes content type header' do
+      allow(subject).to receive(:send) do |req|
+        expect(req['Content-Type']).to eql('application/json; charset=utf-8')
+        Net::HTTPOK.new "1.1", "200", "OK"
+      end
+      subject.multi_receive(events)
+      expect(subject).to have_received(:send)
     end
 
-    it 'should receive the event as a hash' do
-      expect(body).to eql(expected_body)
+    it 'includes user agent' do
+      allow(subject).to receive(:send) do |req|
+        expect(req['User-Agent']).to eql('logstash-output-dynatrace v1.2.3')
+        Net::HTTPOK.new "1.1", "200", "OK"
+      end
+      subject.multi_receive(events)
+      expect(subject).to have_received(:send)
     end
 
-    it 'should have the correct content type' do
-      expect(content_type).to eql(expected_content_type)
+    it 'does not log on success' do
+      allow(subject.logger).to receive(:debug) { raise "should not log" }
+      allow(subject.logger).to receive(:info) { raise "should not log" }
+      allow(subject.logger).to receive(:error) { raise "should not log" }
+      allow(subject.logger).to receive(:warn) { raise "should not log" }
+      allow(subject).to receive(:send) do |req|
+        Net::HTTPOK.new "1.1", "200", "OK"
+      end
+      subject.multi_receive(events)
+      expect(subject).to have_received(:send)
     end
+  end
 
-    it 'should have the correct authorization' do
-      expect(authorization).to eql(expected_authorization)
+  context 'with bad client request' do
+    it 'does not retry on 404' do
+      allow(subject).to receive(:send) { Net::HTTPNotFound.new "1.1", "404", "Not Found" }
+      subject.multi_receive(events)
+      expect(subject).to have_received(:send).once
     end
   end
 
-  context 'with failing requests' do
-    let(:url) { "http://localhost:#{port}/bad" }
+  context 'with server error' do
+    it 'retries 5 times with exponential backoff' do
+      allow(subject).to receive(:sleep)
+      allow(subject).to receive(:send) { Net::HTTPInternalServerError.new "1.1", "500", "Internal Server Error" }
 
-    before do
-      subject.multi_receive([event])
-    end
+      subject.multi_receive(events)
+
+      expect(subject).to have_received(:sleep).with(1).ordered
+      expect(subject).to have_received(:sleep).with(2).ordered
+      expect(subject).to have_received(:sleep).with(4).ordered
+      expect(subject).to have_received(:sleep).with(8).ordered
+      expect(subject).to have_received(:sleep).with(16).ordered
 
-    it 'should log a failure' do
-      expect(subject).to have_received(:log_failure).with(any_args)
+      expect(subject).to have_received(:sleep).exactly(5).times
+      expect(subject).to have_received(:send).exactly(6).times
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-output-dynatrace
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Dynatrace Open Source Engineering
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-16 00:00:00.000000000 Z
+date: 2021-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logstash-codec-json
@@ -152,6 +152,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md