log-courier 1.2 → 1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 18d64c60c7561492f74be1a92bb7ef4cce3d2a98
-  data.tar.gz: 71f010bef4d7c535e453dab752c83830169952ea
+  metadata.gz: 645bd508ce891c3fb1fd69c4a414758fdc55c867
+  data.tar.gz: c4b14fb6f9cc1b75ac2c886d0162b543246ef5c5
 SHA512:
-  metadata.gz: f87ec04d3cc8e91c5e4257157f9a90112ca34d210fbf7bdac4ac78c58068c7dd529e14657947e150996ebc6dd85f3047524fe0d937426f656a742ab1c75dfc50
-  data.tar.gz: 6f82c4989b768bf644683b568f4e8fbc572506e0344093c5ed149e06a00848480bb20437ac1749f515709f66b9a1933ff9267f48afaa709496010abe4361e3d3
+  metadata.gz: 2f512338b7e7a11fff7293a9006ef5a924596f5b7f40863e5f12a68297588e1969628aa6b3730b30bac9464071d9da63186aac9c460bfbe8f92219f42f6731e2
+  data.tar.gz: 736be3625601a89409beee281f432e6450af0a76aa040eb916e848512cfcb195b8bd6b0c6ef013e0a0757fe5237f35acdf9bd273ffe34a9c765e5f81ac4ab841

data/lib/log-courier/client.rb

@@ -30,21 +30,60 @@ module LogCourier
 
   # Describes a pending payload
   class PendingPayload
-    attr_accessor :ack_events
-    attr_accessor :events
-    attr_accessor :nonce
-    attr_accessor :data
+    class << self
+      @json_adapter
+      def get_json_adapter
+        @json_adapter = MultiJson.adapter.instance if @json_adapter.nil?
+        return @json_adapter
+      end
+    end
 
-    attr_accessor :previous
     attr_accessor :next
+    attr_accessor :nonce
+    attr_accessor :events
+    attr_accessor :last_sequence
+    attr_accessor :sequence_len
+    attr_accessor :payload
 
-    def initialize(options = {})
-      @ack_events = 0
+    def initialize(events, nonce)
+      @events = events
+      @nonce = nonce
+
+      generate
+    end
+
+    def generate
+      fail ArgumentError, 'Corrupt payload' if @events.length == 0
+
+      buffer = Zlib::Deflate.new
 
-      options.each do |k, v|
-        fail ArgumentError unless self.respond_to?(k)
-        instance_variable_set "@#{k}", v
+      # Write each event in JSON format
+      events.each do |event|
+        json_data = self.class.get_json_adapter.dump(event)
+        # Add length and then the data
+        buffer << [json_data.length].pack('N') << json_data
       end
+
+      # Generate and store the payload
+      @payload = nonce + buffer.flush(Zlib::FINISH)
+      @last_sequence = 0
+      @sequence_len = @events.length
+    end
+
+    def ack(sequence)
+      if sequence <= @last_sequence
+        return 0, false
+      elsif sequence >= @sequence_len
+        lines = @sequence_len - @last_sequence
+        @last_sequence = sequence
+        @payload = nil
+        return lines, true
+      end
+
+      lines = sequence - @last_sequence
+      @last_sequence = sequence
+      @payload = nil
+      return lines, false
     end
   end
 
@@ -63,9 +102,6 @@ module LogCourier
       require 'log-courier/client_tls'
       @client = ClientTls.new(@options)
 
-      # Load the json adapter
-      @json_adapter = MultiJson.adapter.instance
-
       @event_queue = EventQueue.new @options[:spool_size]
       @pending_payloads = {}
       @first_payload = nil
@@ -100,7 +136,7 @@ module LogCourier
       @io_thread.raise ShutdownSignal
       @spooler_thread.join
       @io_thread.join
-      return
+      return @pending_payloads.length == 0
     end
 
     private
@@ -274,14 +310,9 @@ module LogCourier
     def send_jdat(events)
       # Generate the JSON payload and compress it
       nonce = generate_nonce
-      data = buffer_jdat_data(events, nonce)
 
       # Save the pending payload
-      payload = PendingPayload.new(
-        :events => events,
-        :nonce  => nonce,
-        :data   => data
-      )
+      payload = PendingPayload.new(events, nonce)
 
       @pending_payloads[nonce] = payload
 
@@ -294,27 +325,7 @@ module LogCourier
       end
 
       # Send it
-      @client.send 'JDAT', payload.data
-      return
-    end
-
-    def buffer_jdat_data(events, nonce)
-      buffer = Zlib::Deflate.new
-
-      # Write each event in JSON format
-      events.each do |event|
-        buffer_jdat_data_event(buffer, event)
-      end
-
-      # Generate and return the message
-      nonce + buffer.flush(Zlib::FINISH)
-    end
-
-    def buffer_jdat_data_event(buffer, event)
-      json_data = @json_adapter.dump(event)
-
-      # Add length and then the data
-      buffer << [json_data.length].pack('N') << json_data
+      @client.send 'JDAT', payload.payload
       return
     end
 
@@ -322,6 +333,8 @@ module LogCourier
       # Sanity
       fail ProtocolError, "Unexpected data attached to pong message (#{message.length})" if message.length != 0
 
+      @logger.debug 'PONG message received' unless @logger.nil? || !@logger.debug?
+
       # No longer pending a PONG
       @ping_pending = false
       return
@@ -332,29 +345,27 @@ module LogCourier
       fail ProtocolError, "ACKN message size invalid (#{message.length})" if message.length != 20
 
       # Grab nonce
-      sequence, nonce = message[0...4].unpack('N').first, message[4..-1]
+      nonce, sequence = message.unpack('A16N')
+
+      if !@logger.nil? && @logger.debug?
+        nonce_str = nonce.each_byte.map do |b|
+          b.to_s(16).rjust(2, '0')
+        end
+
+        @logger.debug 'ACKN message received', :nonce => nonce_str.join, :sequence => sequence
+      end
 
       # Find the payload - skip if we couldn't as it will just a duplicated ACK
       return unless @pending_payloads.key?(nonce)
 
       payload = @pending_payloads[nonce]
+      lines, complete = payload.ack(sequence)
 
-      # Full ACK?
-      # TODO: protocol error if sequence too large?
-      if sequence >= payload.events.length
-        @client.resume_send if @client.send_paused?
-
+      if complete
         @pending_payloads.delete nonce
-        payload.previous.next = payload.next
-      else
-        # Partial ACK - only process if something was actually processed
-        if sequence > payload.ack_events
-          payload.ack_events = sequence
-          payload.events = payload.events[0...sequence]
-          payload.data = nil
-        end
+        @first_payload = payload.next
+        @client.resume_send if @client.send_paused?
       end
-      return
     end
   end
 end

data/lib/log-courier/client_tls.rb

@@ -52,14 +52,15 @@ module LogCourier
     end
 
     def connect(io_control)
-      begin
-        tls_connect
-      rescue ShutdownSignal
-        raise
-      rescue
+      loop do
+        begin
+          break if tls_connect
+        rescue ShutdownSignal
+          raise
+        end
+
         # TODO: Make this configurable
         sleep 5
-        retry
       end
 
       @send_q = SizedQueue.new 1
@@ -88,6 +89,25 @@ module LogCourier
       return
     end
 
+    def pause_send
+      return if @send_paused
+      @send_paused = true
+      @send_q << nil
+      return
+    end
+
+    def send_paused?
+      @send_paused
+    end
+
+    def resume_send
+      if @send_paused
+        @send_paused = false
+        @send_q << nil
+      end
+      return
+    end
+
     private
 
     def run_send(io_control)
@@ -170,25 +190,6 @@ module LogCourier
       return
     end
 
-    def pause_send
-      return if @send_paused
-      @send_paused = true
-      @send_q << nil
-      return
-    end
-
-    def send_paused
-      @send_paused
-    end
-
-    def resume_send
-      if @send_paused
-        @send_paused = false
-        @send_q << nil
-      end
-      return
-    end
-
     def tls_connect
       # TODO: Implement random selection - and don't use separate :port - remember to update post_connection_check too
       address = @options[:addresses][0]
@@ -208,7 +209,7 @@ module LogCourier
 
         cert_store = OpenSSL::X509::Store.new
         cert_store.add_file(@options[:ssl_ca])
-        #ssl.cert_store = cert_store
+        ssl.cert_store = cert_store
         ssl.verify_mode = OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
 
         @ssl_client = OpenSSL::SSL::SSLSocket.new(tcp_socket)
@@ -223,16 +224,14 @@ module LogCourier
         @logger['port'] = port
 
         @logger.info 'Connected successfully' unless @logger.nil?
-        return
+        return true
       rescue OpenSSL::SSL::SSLError, IOError, Errno::ECONNRESET => e
         @logger.warn 'Connection failed', :error => e.message, :address => address, :port => port unless @logger.nil?
-        return
-      rescue ShutdownSignal
-        return
       rescue StandardError, NativeException => e
         @logger.warn e, :hint => 'Unknown connection failure', :address => address, :port => port unless @logger.nil?
-        raise e
       end
+
+      false
     end
   end
 end

data/lib/log-courier/server.rb

@@ -181,6 +181,9 @@ module LogCourier
           event = { 'message' => data_buf }
         end
 
+        # Add peer fields?
+        comm.add_fields event
+
         # Queue the event
         begin
           event_queue.push event, [0, ack_timeout - Time.now.to_i].max

data/lib/log-courier/server_tcp.rb

@@ -63,6 +63,7 @@ module LogCourier
         ssl_verify_default_ca: false,
         ssl_verify_ca:         nil,
         max_packet_size:       10_485_760,
+        add_peer_fields:       false,
       }.merge!(options)
 
       @logger = @options[:logger]
@@ -156,7 +157,7 @@ module LogCourier
     rescue StandardError, NativeException => e
       # Some other unknown problem
       @logger.warn e, :hint => 'Unknown error, shutting down' unless @logger.nil?
-      raise e
+      return
     ensure
       # Raise shutdown in all client threads and join then
       client_threads.each do |_, thr|
@@ -195,8 +196,20 @@ module LogCourier
       @logger = logger
       @fd = fd
       @peer = peer
+      @peer_fields = {}
       @in_progress = false
       @options = options
+
+      if @options[:add_peer_fields]
+        @peer_fields['peer'] = peer
+        if @options[:transport] == 'tls' && !@fd.peer_cert.nil?
+          @peer_fields['peer_ssl_cn'] = get_cn(@fd.peer_cert)
+        end
+      end
+    end
+
+    def add_fields(event)
+      event.merge! @peer_fields if @peer_fields.length != 0
     end
 
     def run
@@ -284,6 +297,13 @@ module LogCourier
 
     private
 
+    def get_cn(cert)
+      cert.subject.to_a.find do |oid, value|
+        return value if oid == "CN"
+      end
+      nil
+    end
+
     def recv(need)
       reset_timeout
       have = ''

data/lib/log-courier/server_zmq.rb

@@ -66,8 +66,14 @@ module LogCourier
 
       begin
         @context = ZMQ::Context.new
+        fail ZMQError, 'context creation error: ' + ZMQ::Util.error_string if @context.nil?
+
         # Router so we can send multiple responses
         @socket = @context.socket(ZMQ::ROUTER)
+        fail ZMQError, 'socket creation error: ' + ZMQ::Util.error_string if @socket.nil?
+
+        rc = @socket.setsockopt(ZMQ::LINGER, 0)
+        fail ZMQError, 'setsockopt LINGER failure: ' + ZMQ::Util.error_string unless ZMQ::Util.resultcode_ok?(rc)
 
         if @options[:transport] == 'zmq'
           rc = @socket.setsockopt(ZMQ::CURVE_SERVER, 1)
@@ -104,20 +110,10 @@ module LogCourier
       @poller = ZMQPoll::ZMQPoll.new(@context)
       @poller.register_socket @socket, ZMQ::POLLIN
       @poller.register_queue_to_socket @send_queue, @socket
-
-      # Register a finaliser that sets @context to nil
-      # This allows us to detect the JRuby bug where during "exit!" finalisers
-      # are run but threads are not killed - which leaves us in a situation of
-      # a terminated @context (it has a terminate finalizer) and an IO thread
-      # looping retries
-      # JRuby will still crash and burn, but at least we don't spam STDOUT with
-      # errors
-      ObjectSpace.define_finalizer(self, Proc.new do
-        @context = nil
-      end)
     end
 
     def run(&block)
+      errors = 0
       loop do
         begin
           @poller.poll(5_000) do |socket, r, w|
@@ -126,11 +122,14 @@ module LogCourier
 
             receive &block
           end
+          errors = 0
         rescue ZMQPoll::ZMQError => e
-          # Detect JRuby bug
-          fail e if @context.nil?
-          @logger.warn e, :hint => 'ZMQ recv_string failure' unless @logger.nil?
+          @logger.warn e, :hint => 'ZMQ poll failure' unless @logger.nil?
           next
+        rescue ZMQPoll::ZMQTerm
+          # Fall into shutdown signal, context was terminated
+          # This can happen in JRuby - it seems to run finalisers too early
+          fail ShutdownSignal
         rescue ZMQPoll::TimeoutError
           # We'll let ZeroMQ manage reconnections and new connections
           # There is no point in us doing any form of reconnect ourselves
@@ -145,7 +144,7 @@ module LogCourier
     rescue StandardError, NativeException => e
       # Some other unknown problem
       @logger.warn e, :hint => 'Unknown error, shutting down' unless @logger.nil?
-      raise e
+      return
     ensure
       @poller.shutdown
       @factory.shutdown
@@ -259,7 +258,7 @@ module LogCourier
 
           # Create the client and associated thread
           client = ClientZmq.new(self, source, source_str) do
-            try_drop(source)
+            try_drop source, source_str
           end
 
           thread = Thread.new do
@@ -366,6 +365,9 @@ module LogCourier
       return
     end
 
+    def add_fields(event)
+    end
+
     private
 
     def recv(data)

data/lib/log-courier/zmq_qpoll.rb

@@ -0,0 +1,324 @@
+# encoding: utf-8
+
+# Copyright 2014 Jason Woods.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+begin
+	require 'ffi-rzmq'
+	require 'ffi-rzmq/version'
+	require 'ffi-rzmq-core/version'
+rescue LoadError => e
+	raise "ZMQPoll could not initialise: #{e}"
+end
+
+module ZMQPoll
+	class ZMQError < StandardError; end
+	class ZMQTerm < StandardError; end
+	class TimeoutError < StandardError; end
+
+	class ZMQPoll
+		def initialize(context, logger=nil)
+			@logger = logger
+			@context = context
+			@poller = ZMQ::Poller.new
+			@sockets = []
+			@socket_to_socket = []
+			@handlers = {}
+			@queues = {}
+		end
+
+		def readables
+			@poller.readables
+		end
+
+		def writables
+			@poller.writables
+		end
+
+		def shutdown
+			@queues.each_key do |queue|
+				deregister_queue queue
+			end
+
+			@socket_to_socket.each do |socket|
+				_close_socket_to_socket socket
+			end
+
+			@sockets.each do |socket|
+				socket.close
+			end
+			return
+		end
+
+		def register_socket(socket, flags)
+			@poller.register socket, flags
+			return
+		end
+
+		def deregister_socket(socket)
+			return if @handlers.key?(socket)
+
+			@poller.delete socket
+			return
+		end
+
+		def register_queue_to_socket(queue, socket)
+			s2s_state = _create_socket_to_socket(socket)
+
+			state = {
+				state:    s2s_state,
+				mutex:    Mutex.new,
+				shutdown: false,
+			}
+
+			state[:thread] = Thread.new do
+				loop do
+					data = queue.pop
+					break if data.nil?
+					begin
+						send s2s_state[:sender], data
+					rescue TimeoutError
+						state[:mutex].synchronize do
+							break if state[:shutdown]
+						end
+						retry
+					end
+				end
+			end
+
+			@queues[queue] = state
+			return
+		end
+
+		def deregister_queue(queue)
+			return if !@queues.key?(queue)
+
+			# Push nil so if we're idle we jump into action and exit
+			# But also set shutdown to try so if we're mid-send and timeout, we exit
+			@queues[queue][:mutex].synchronize do
+				queue.push nil
+				@queues[queue][:shutdown] = true
+			end
+			@queues[queue][:thread].join
+
+			_close_socket_to_socket @queues[queue][:state]
+			@queues.delete queue
+			return
+		end
+
+		def create_socket_to_socket(socket)
+			state = _create_socket_to_socket(socket)
+			@socket_to_socket[state[:sender]] = state
+			state[:sender]
+		end
+
+		def close_socket_to_socket(socket)
+			return if !@socket_to_socket.include?(socket)
+			state = @socket_to_socket[socket]
+			@socket_to_socket.delete socket
+			_close_socket_to_socket(state)
+			return
+		end
+
+		def poll(timeout)
+			if @poller.size == 0
+				fail ZMQError, 'poll run called with zero socket/queues'
+			end
+
+			rc = @poller.poll(timeout)
+			unless ZMQ::Util.resultcode_ok?(rc)
+				# If we get ETERM or ENOTSOCK - we may have hit JRuby bug where finalisers are called too early
+				# We throw it so the caller knows NOT to retry and hit a bad loop
+				# The downside is - this Jruby bug will cause an inevitable deadlock
+				# The finaliser for the context will have run before finalisers for sockets (random order?)
+				# The resulting ZMQ context termination will block, waiting for sockets to be closed
+				# However, when closing a socket, ffi-rzmq will attempt to remove it's finaliser
+				# This removal will deadlock as it attempts to lock the finaliser list, which is locked by the
+				# thread that is running the ZMQ context termination, which is blocked...
+				# TODO: Raise issue in JRuby github and try to track down why finalisers run while code is running
+				# if the exit! call is made
+				fail ZMQTerm, 'poll error: ' + ZMQ::Util.error_string if ZMQ::Util.errno == ZMQ::ETERM || ZMQ::Util.errno == ZMQ::ENOTSOCK
+				fail ZMQError, 'poll error: ' + ZMQ::Util.error_string
+			end
+
+			return if rc == 0
+
+			ready = (@poller.readables|@poller.writables)
+
+			ready.each do |socket|
+				if @handlers.key?(socket)
+					__send__ @handlers[socket][:callback], @handlers[socket]
+				end
+
+				yield socket, @poller.readables.include?(socket), @poller.writables.include?(socket)
+			end
+
+			return
+		end
+
+		private
+
+		def _create_socket_to_socket(socket)
+			receiver = @context.socket(ZMQ::PULL)
+			fail ZMQError, 'socket creation error: ' + ZMQ::Util.error_string if receiver.nil?
+
+			rc = receiver.setsockopt(ZMQ::LINGER, 0)
+			fail ZMQError, 'setsockopt LINGER failure: ' + ZMQ::Util.error_string unless ZMQ::Util.resultcode_ok?(rc)
+
+			rc = receiver.bind("inproc://zmqpollreceiver-#{receiver.hash}")
+			fail ZMQError, 'bind error: ' + ZMQ::Util.error_string unless ZMQ::Util.resultcode_ok?(rc)
+
+			sender = @context.socket(ZMQ::PUSH)
+			fail ZMQError, 'socket creation error: ' + ZMQ::Util.error_string if sender.nil?
+
+			rc = sender.setsockopt(ZMQ::LINGER, 0)
+			fail ZMQError, 'setsockopt LINGER failure: ' + ZMQ::Util.error_string unless ZMQ::Util.resultcode_ok?(rc)
+
+			rc = sender.connect("inproc://zmqpollreceiver-#{receiver.hash}")
+			fail ZMQError, 'bind error: ' + ZMQ::Util.error_string unless ZMQ::Util.resultcode_ok?(rc)
+
+			state = {
+				:callback => :handle_socket_to_socket,
+				:sender   => sender,
+				:receiver => receiver,
+				:socket   => socket,
+				:buffer   => nil,
+				:send_ok  => false,
+				:recv_ok  => false,
+			}
+
+			@poller.register receiver, ZMQ::POLLIN
+			@poller.register socket, ZMQ::POLLOUT
+			@handlers[receiver] = state
+			@handlers[socket] = state
+
+			@sockets.push sender
+
+			state
+		end
+
+		def _close_socket_to_socket(state)
+			@sockets.delete state[:sender]
+
+			@poller.delete state[:receiver]
+			@poller.delete state[:socket]
+
+			state[:sender].close
+			state[:receiver].close
+
+			@handlers.delete state[:receiver]
+			@handlers.delete state[:socket]
+
+			return
+		end
+
+		def handle_socket_to_socket(state)
+			state[:recv_ok] = @poller.readables.include?(state[:receiver]) || state[:recv_ok]
+			state[:send_ok] = @poller.writables.include?(state[:socket]) || state[:send_ok]
+
+			loop do
+				if state[:send_ok] && !state[:buffer].nil?
+					begin
+						send state[:socket], state[:buffer]
+					rescue TimeoutError
+					end
+					state[:buffer] = nil if state[:buffer].length == 0
+					state[:send_ok] = false
+				end
+
+				break if !state[:recv_ok]
+
+				if state[:recv_ok] && state[:buffer].nil?
+					begin
+						state[:buffer] = recv(state[:receiver])
+					rescue TimeoutError
+					end
+					state[:recv_ok] = false
+				end
+
+				break if !state[:send_ok]
+			end
+
+			if state[:recv_ok]
+				@poller.deregister state[:receiver], ZMQ::POLLIN
+			else
+				@poller.register state[:receiver], ZMQ::POLLIN
+			end
+
+			if state[:send_ok]
+				@poller.deregister state[:socket], ZMQ::POLLOUT
+			else
+				@poller.register state[:socket], ZMQ::POLLOUT
+			end
+
+			return
+		end
+
+		def recv(socket)
+			data = []
+
+			poll_eagain(socket, ZMQ::POLLIN, 5) do
+				# recv_strings appears to be safe, ZMQ documents that a client will either
+				# receive 0 parts or all parts
+				socket.recv_strings(data, ZMQ::DONTWAIT)
+			end
+
+			data
+		end
+
+		def send(socket, data)
+			while data.length != 1
+				send_part socket, data.shift, true
+			end
+			send_part socket, data.shift
+			return
+		end
+
+		def send_part(socket, data, more=false)
+			poll_eagain(socket, ZMQ::POLLOUT, 5) do
+				# Try to send a message but never block
+				# We could use send_strings but it is vague on if ZMQ can return an
+				# error midway through sending parts...
+				socket.send_string(data, (more ? ZMQ::SNDMORE : 0) | ZMQ::DONTWAIT)
+			end
+
+			return
+		end
+
+		def poll_eagain(socket, flag, timeout, &block)
+			poller = nil
+			timeout = Time.now.to_i + timeout
+			loop do
+				rc = block.call()
+				break if ZMQ::Util.resultcode_ok?(rc)
+				if ZMQ::Util.errno != ZMQ::EAGAIN
+					fail ZMQError, 'message receive failed: ' + ZMQ::Util.error_string if flag == ZMQ::POLLIN
+					fail ZMQError, 'message send failed: ' + ZMQ::Util.error_string
+				end
+
+				# Wait for send to become available, handling timeouts
+				if poller.nil?
+					poller = ZMQ::Poller.new
+					poller.register socket, flag
+				end
+
+				while poller.poll(1_000) == 0
+					# Using this inner while triggers pollThreadEvents in JRuby which checks for Thread.raise immediately
+					fail TimeoutError while Time.now.to_i >= timeout
+				end
+			end
+			return
+		end
+	end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: log-courier
 version: !ruby/object:Gem::Version
-  version: '1.2'
+  version: '1.3'
 platform: ruby
 authors:
 - Jason Woods
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-02 00:00:00.000000000 Z
+date: 2015-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cabin
@@ -65,6 +65,7 @@ files:
 - lib/log-courier/server.rb
 - lib/log-courier/server_tcp.rb
 - lib/log-courier/server_zmq.rb
+- lib/log-courier/zmq_qpoll.rb
 homepage: https://github.com/driskell/log-courier
 licenses:
 - Apache