slack_log_device 2.2.3 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc81637219036304853c58b3abdff5b0461746b6
-  data.tar.gz: cbd0673773540ba8b65ed7f7ed24a2a508a46df8
+  metadata.gz: 7da84e6d177382ef3698ba25b1cafddfd7e41e9d
+  data.tar.gz: 9643a365bff66ea7ea8219d38c73dcad7166185e
 SHA512:
-  metadata.gz: 58320e47d7af2785ed9cf2c03a8770e5fa32ed4be7e3225491a9c36541693ba5be039a02aacb54e63d7761c9c4f7c9121b6a959eb24436722ec4882bebdbf9ef
-  data.tar.gz: 9e3d6ac73a9b43877069efc40adb431629131d5a2c99a7b3f7bc759fb443c846f51f2d6eec5b650e48d0adbf3f517a3a1596fb5c2a5b51bb1c83010de91697a2
+  metadata.gz: a25cdda1fa68d846b11405ade1d656b0b0d349db2faa3c798290643ae58e78cd878e81eec53cfb204ceececdfc2a31a75b1561d8394d1450cf29f05e0e552f32
+  data.tar.gz: 44c2fda8c1c618aee82cd46fc6a6bf48445826290048fd269817da57daa34ddbc54a9e4a954e99069f35c794f628a111e86b26a0a120b2b6cadd4eaf4c751aaa

data/README.mdown

@@ -46,7 +46,14 @@ starting with a `@`).
 It can be configured like this:
 
 ```ruby
-logger.formatter = SlackLogDevice::FORMATTER
+logger.formatter = SlackLogDevice.formatter
+```
+
+`SlackLogDevice.formatter` method also accepts block to transform logged
+message, example:
+
+```ruby
+logger.formatter = SlackLogDevice.formatter { |message| message.reverse }
 ```
 
 ## Rails configuration

data/VERSION

@@ -1 +1 @@
-2.2.3
+3.0.0

data/lib/slack_log_device/formatter.rb

@@ -0,0 +1,94 @@
+class SlackLogDevice
+
+  class Formatter
+
+    MAX_MESSAGE_LENGTH = 4000
+
+    attr_reader :extra_metadata
+
+    def initialize(options = {}, &block)
+      options.assert_valid_keys(:extra_metadata)
+      @extra_metadata = options.key?(:extra_metadata) ? options[:extra_metadata] : {}
+      @message_conveter = block_given? ? Proc.new(&block) : -> (message) { message }
+    end
+
+    def call(severity, datetime, progname, message)
+      text = "*`#{severity}`*"
+      text << " (*#{progname}*)" if progname.present?
+      text << ':'
+      if message.is_a?(Exception)
+        exception = message
+        text << " A `#{message.class}` occurred: #{convert_message(exception.message)}".rstrip
+        text = truncate(text)
+        text = append_metadata(text, exception)
+        text = append_backtrace(text, exception)
+      else
+        text << " #{convert_message(message)}".rstrip
+        text = append_metadata(text, message)
+      end
+      truncate(text)
+    end
+
+    private
+
+    def append_backtrace(text, exception)
+      backtrace = format_backtrace(exception, MAX_MESSAGE_LENGTH - text.size - 2)
+      text << "\n\n" << backtrace if backtrace.present?
+      text
+    end
+
+    def append_metadata(text, message)
+      metadata = format_metadata(message, MAX_MESSAGE_LENGTH - text.size - 2)
+      text << "\n\n" << metadata if metadata.present?
+      text
+    end
+
+    def convert_message(message)
+      @message_conveter.call(message.to_s.strip).to_s.strip
+    end
+
+    def default_metadata(request)
+      return {} if request.blank?
+      metadata = {
+        'Method' => request.method,
+        'URL' => request.url,
+        'Remote address' => request.remote_addr,
+        'User-Agent' => request.user_agent,
+      }
+      metadata.keys.each do |key|
+        value = metadata[key]
+        metadata[key] = "`#{value.strip}`" if value.present?
+      end
+      metadata
+    end
+
+    def format_backtrace(exception, size_available)
+      backtrace = exception.backtrace.try(:join, "\n")
+      return nil if backtrace.blank? || size_available < 7
+      "```#{truncate(backtrace, size_available - 6)}```"
+    end
+
+    def format_metadata(message, size_available)
+      return nil if size_available < 11
+      options = {}
+      options[:exception] = message if message.is_a?(Exception)
+      request = options[:exception].present? ? options[:exception].instance_variable_get(:@__slack_log_device_request) : nil
+      options[:request] = request if request.present?
+      text = default_metadata(request).merge(extra_metadata).map do |name, value|
+        value = value.call(options) if value.respond_to?(:call)
+        value.present? ? "• *#{name.strip}*: #{value.strip}" : nil
+      end.compact.join("\n")
+      return nil if text.blank?
+      truncate(text, size_available)
+    end
+
+    def truncate(message, max_length = MAX_MESSAGE_LENGTH)
+      message = message.strip
+      return message if message.size <= max_length
+      return message[0, max_length] if max_length < 3
+      "#{message[0, max_length - 3]}..."
+    end
+
+  end
+
+end

data/lib/slack_log_device/rails_exceptions_logging.rb

@@ -0,0 +1,16 @@
+class SlackLogDevice
+
+  module RailsExceptionsLogging
+
+    def log_error(request, wrapper)
+      logger = logger(request)
+      return unless logger
+      exception = wrapper.exception
+      return if defined?(ActionController::RoutingError) && exception.is_a?(ActionController::RoutingError)
+      exception.instance_variable_set(:@__slack_log_device_request, request)
+      logger.fatal(exception)
+    end
+
+  end
+
+end

data/lib/slack_log_device.rb

@@ -5,26 +5,15 @@ require 'logger'
 
 class SlackLogDevice
 
-  FORMATTER = -> (severity, datetime, progname, message) do
-    text = "*`#{severity}`*"
-    text << " (*#{progname}*)" if progname.present?
-    text << ': '
-    if message.is_a?(Exception)
-      text << "A `#{message.class}` occurred: #{message.message}\n\n```"
-      backtrace = message.backtrace.join("\n")
-      backtrace = backtrace[0, MAX_MESSAGE_LENGTH - 6 - text.size] << "..." if backtrace.size > MAX_MESSAGE_LENGTH - 3
-      text << backtrace << '```'
-    else
-      text << message
-    end
-  end
-  MAX_MESSAGE_LENGTH = 4000
-
   attr_reader :channel, :flush_delay, :max_buffer_size, :timeout, :username, :webhook_url
 
+  def self.formatter(options = {}, &block)
+    Formatter.new(options, &block)
+  end
+
   def initialize(options = {})
     options.assert_valid_keys(:auto_flush, :channel, :flush_delay, :max_buffer_size, :timeout, :username, :webhook_url)
-    @buffer = []
+    @buffer = ''
     @mutex = Mutex.new
     @flush_thread
     self.auto_flush = options[:auto_flush]
@@ -58,8 +47,8 @@ class SlackLogDevice
     return if @buffer.empty?
     message = ''
     @mutex.synchronize do
-      message = @buffer.join("\n")
-      @buffer.clear
+      message = @buffer
+      @buffer = ''
     end
     data = { 'text' => message.to_s }
     data['channel'] = channel if channel.present?
@@ -73,7 +62,7 @@ class SlackLogDevice
   end
 
   def flush?
-    auto_flush? || flush_delay.zero? || @buffer.join("\n").bytesize > max_buffer_size
+    auto_flush? || flush_delay.zero? || @buffer.bytesize > max_buffer_size || @buffer.include?('```')
   end
 
   def flush_delay=(value)
@@ -109,6 +98,7 @@ class SlackLogDevice
     message = message.to_s.try(:strip)
     return if message.blank?
     @mutex.synchronize do
+      @buffer << "\n" unless @buffer.empty?
       @buffer << message
     end
     @flush_thread.kill if @flush_thread
@@ -124,3 +114,10 @@ class SlackLogDevice
   end
 
 end
+
+require 'slack_log_device/rails_exceptions_logging'
+require 'slack_log_device/formatter'
+
+if defined?(ActionDispatch::DebugExceptions)
+  ActionDispatch::DebugExceptions.prepend(SlackLogDevice::RailsExceptionsLogging)
+end

data/spec/slack_log_device/formatter_spec.rb

@@ -0,0 +1,277 @@
+require 'spec_helper'
+
+describe SlackLogDevice::Formatter do
+
+  let(:max_message_length) { SlackLogDevice::Formatter::MAX_MESSAGE_LENGTH }
+
+  describe '::MAX_MESSAGE_LENGTH' do
+
+    it 'is 4000' do
+      expect(SlackLogDevice::Formatter::MAX_MESSAGE_LENGTH).to be(4000)
+    end
+
+  end
+
+  describe '#call' do
+
+    context "with no block or metadata" do
+
+      let(:formatter) { SlackLogDevice::Formatter.new }
+
+      it 'returns a formatted message' do
+        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq('*`DEBUG`*: Hello World')
+      end
+
+      it 'message is stripped' do
+        expect(formatter.call('DEBUG', Time.now, ' ', " \nHello World   ")).to eq('*`DEBUG`*: Hello World')
+      end
+
+      it 'message is converted to string' do
+        expect(formatter.call('DEBUG', Time.now, ' ', 42)).to eq('*`DEBUG`*: 42')
+      end
+
+      it 'includes progname if given' do
+        expect(formatter.call('DEBUG', Time.now, 'My App', 'Hello World')).to eq('*`DEBUG`* (*My App*): Hello World')
+      end
+
+      it 'formats exception' do
+        exception = RuntimeError.new('BAM!')
+        exception.set_backtrace(['foo', 'bar'])
+        expect(formatter.call('DEBUG', Time.now, nil, exception)).to eq("*`DEBUG`*: A `RuntimeError` occurred: BAM!\n\n```foo\nbar```")
+      end
+
+      it 'formats exception with no message' do
+        exception = RuntimeError.new(' ')
+        exception.set_backtrace(['foo', 'bar'])
+        expect(formatter.call('DEBUG', Time.now, nil, exception)).to eq("*`DEBUG`*: A `RuntimeError` occurred:\n\n```foo\nbar```")
+      end
+
+      it 'formats exception with no backtrace' do
+        exception = RuntimeError.new('BAM!')
+        expect(formatter.call('DEBUG', Time.now, nil, exception)).to eq("*`DEBUG`*: A `RuntimeError` occurred: BAM!")
+      end
+
+      it 'strips exception message' do
+        exception = RuntimeError.new("  BAM!   \n")
+        expect(formatter.call('DEBUG', Time.now, nil, exception)).to eq("*`DEBUG`*: A `RuntimeError` occurred: BAM!")
+      end
+
+      it 'message never exceed 4000 chars (without exception)' do
+        message = formatter.call('DEBUG', Time.now, nil, 'Bam' * (max_message_length / 2))
+        expect(message.size).to eq(max_message_length)
+        expect(message).to end_with('BamBa...')
+      end
+
+      it 'message never exceed 4000 chars (with exception)' do
+        exception = RuntimeError.new('BAM!')
+        exception.set_backtrace(['a' * (max_message_length - 49)])
+        message = formatter.call('DEBUG', Time.now, nil, exception)
+        expect(message.size).to eq(max_message_length)
+        expect(message).to end_with("aaaaaa...```")
+      end
+
+      it 'can be exactly 4000 chars with trace (without three dots)' do
+        exception = RuntimeError.new('BAM!')
+        exception.set_backtrace(['a' * (max_message_length - 50)])
+        message = formatter.call('DEBUG', Time.now, nil, exception)
+        expect(message.size).to eq(max_message_length)
+        expect(message).to end_with('a```')
+      end
+
+      it 'does not add three dots if less than 4000' do
+        exception = RuntimeError.new('BAM!')
+        exception.set_backtrace(['a' * (max_message_length - 51)])
+        message = formatter.call('DEBUG', Time.now, nil, exception)
+        expect(message.size).to eq(max_message_length - 1)
+        expect(message).to end_with('a```')
+      end
+
+      it 'does not format backtrace if message is too long' do
+        exception = RuntimeError.new('BAM!' * max_message_length)
+        exception.set_backtrace(['hello world'])
+        message = formatter.call('DEBUG', Time.now, nil, exception)
+        expect(message.size).to eq(max_message_length)
+        expect(message).not_to include('hello')
+        expect(message).not_to include('```')
+      end
+
+      it 'message does not exceed 4000 if there is no backtrace' do
+        exception = RuntimeError.new('BAM!' * max_message_length)
+        message = formatter.call('DEBUG', Time.now, nil, exception)
+        expect(message.size).to eq(max_message_length)
+      end
+
+      it 'does not formats a blank backtrace (due to large message)' do
+        exception = RuntimeError.new('a' * (max_message_length - 46))
+        exception.set_backtrace(['hello world'])
+        message = formatter.call('DEBUG', Time.now, nil, exception)
+        expect(message.size).to eq(max_message_length - 8)
+        expect(message).not_to include('```')
+        expect(message).to end_with('a')
+      end
+
+      it 'can format a backtrace with just one char' do
+        exception = RuntimeError.new('a' * (max_message_length - 47))
+        exception.set_backtrace(['hello world'])
+        message = formatter.call('DEBUG', Time.now, nil, exception)
+        expect(message.size).to eq(max_message_length)
+        expect(message).to end_with("aaa\n\n```h```")
+      end
+
+      it 'can format a backtrace with just one char and three dots' do
+        exception = RuntimeError.new('a' * (max_message_length - 50))
+        exception.set_backtrace(['hello world'])
+        message = formatter.call('DEBUG', Time.now, nil, exception)
+        expect(message.size).to eq(max_message_length)
+        expect(message).to end_with("aaa\n\n```h...```")
+      end
+
+    end
+
+    context 'if a block is given' do
+
+      let(:formatter) { SlackLogDevice::Formatter.new { |message| "#{message.reverse} Hey hoy" } }
+
+      it 'returns formatter message with block invoked' do
+        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq("*`DEBUG`*: dlroW olleH Hey hoy")
+      end
+
+      it 'invokes block with stripped message' do
+        expect(formatter.call('DEBUG', Time.now, ' ', "    Hello World  \t")).to eq("*`DEBUG`*: dlroW olleH Hey hoy")
+      end
+
+      it 'does not append block message if blank' do
+        formatter = SlackLogDevice.formatter { '   ' }
+        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq('*`DEBUG`*:')
+      end
+
+      it 'converts block value to string' do
+        formatter = SlackLogDevice.formatter { 42 }
+        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq('*`DEBUG`*: 42')
+      end
+
+      it 'is correct if block returns nil' do
+        formatter = SlackLogDevice.formatter { nil }
+        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq('*`DEBUG`*:')
+      end
+
+      it 'strips block return value' do
+        formatter = SlackLogDevice.formatter { "  hey \n" }
+        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq('*`DEBUG`*: hey')
+      end
+
+      it 'includes progname if given' do
+        expect(formatter.call('DEBUG', Time.now, 'MyApp', 'Hello World')).to eq("*`DEBUG`* (*MyApp*): dlroW olleH Hey hoy")
+      end
+
+      it 'formats exception' do
+        exception = RuntimeError.new('BAM!')
+        exception.set_backtrace(['foo', 'bar'])
+        expect(formatter.call('DEBUG', Time.now, nil, exception)).to eq("*`DEBUG`*: A `RuntimeError` occurred: !MAB Hey hoy\n\n```foo\nbar```")
+      end
+
+      it 'is correct with exception if block returns a blank message' do
+        formatter = SlackLogDevice.formatter { '    ' }
+        exception = RuntimeError.new('BAM!')
+        exception.set_backtrace(['foo', 'bar'])
+        expect(formatter.call('DEBUG', Time.now, nil, exception)).to eq("*`DEBUG`*: A `RuntimeError` occurred:\n\n```foo\nbar```")
+      end
+
+      it 'message never exceed 4000 chars (without exception)' do
+        message = formatter.call('DEBUG', Time.now, ' ', 'Hello World' * (max_message_length / 3))
+        expect(message.size).to eq(max_message_length)
+        expect(message).to end_with('olleHdlro...')
+      end
+
+      it 'message never exceed 4000 chars (with exception)' do
+        exception = RuntimeError.new('BAM!')
+        exception.set_backtrace(['a' * max_message_length])
+        message = formatter.call('DEBUG', Time.now, 'My App', exception)
+        expect(message.size).to eq(max_message_length)
+        expect(message).to end_with("aaaaaa...```")
+      end
+
+    end
+
+    context 'with extra metadata' do
+
+      let(:extra_metadata) {{
+        'User ' => "   `#{user}` ",
+        '  Reversed user' => -> (options) { user.reverse },
+      }}
+      let(:formatter) { SlackLogDevice::Formatter.new(extra_metadata: extra_metadata) }
+      let(:user) { 'John' }
+
+      it 'returns a message formatted' do
+        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq("*`DEBUG`*: Hello World\n\n• *User*: `John`\n• *Reversed user*: nhoJ")
+      end
+
+      it 'returns a message formatted (with exception)' do
+        exception = RuntimeError.new('BAM!')
+        exception.set_backtrace(['a', 'b'])
+        message = formatter.call('DEBUG', Time.now, 'My App', exception)
+        expect(message).to eq("*`DEBUG`* (*My App*): A `RuntimeError` occurred: BAM!\n\n• *User*: `John`\n• *Reversed user*: nhoJ\n\n```a\nb```")
+      end
+
+      it 'extra metadata are not added if message is too long' do
+        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World' * max_message_length)).not_to include('•')
+      end
+
+      it 'extra metadata are not added if message is too long (with exception)' do
+        exception = RuntimeError.new('BAM!' * max_message_length)
+        exception.set_backtrace(['a'])
+        message = formatter.call('DEBUG', Time.now, 'My App', exception)
+        expect(message).not_to include('•')
+      end
+
+      it 'blocks of extra metadata is invoked with options containing exception' do
+        extra_metadata['Exception class'] = -> (options) { options[:exception].class.name }
+        exception = RuntimeError.new('BAM!')
+        expect(formatter.call('DEBUG', Time.now, nil, exception)).to include('• *Exception class*: RuntimeError')
+      end
+
+      it 'blocks of extra metadata does not add exception option if not present' do
+        extra_metadata['Exception?'] = -> (options) { options.key?(:exception) ? 'Yes' : 'No' }
+        expect(formatter.call('DEBUG', Time.now, nil, 'Hello World')).to include("• *Exception?*: No")
+      end
+
+    end
+
+    context 'with an exception with @__slack_log_device_request set' do
+
+      let(:exception) { RuntimeError.new('BAM!').tap { |e| e.instance_variable_set(:@__slack_log_device_request, request) } }
+      let(:formatter) { SlackLogDevice::Formatter.new }
+      let(:request) { double(remote_addr: '127.0.0.1', user_agent: 'Mozilla', method: 'GET', url: 'http://google.com') }
+
+      it 'logs metadata' do
+        expect(formatter.call('DEBUG', Time.now, nil, exception)).to eq("*`DEBUG`*: A `RuntimeError` occurred: BAM!\n\n• *Method*: `GET`\n• *URL*: `http://google.com`\n• *Remote address*: `127.0.0.1`\n• *User-Agent*: `Mozilla`")
+      end
+
+    end
+
+  end
+
+  describe '#extra_metadata' do
+
+    it 'is an empty hash by default' do
+      expect(SlackLogDevice::Formatter.new.extra_metadata).to eq({})
+    end
+
+    it 'can be specified at constructor' do
+      formatter = SlackLogDevice::Formatter.new(extra_metadata: { 'Bar' => 'foo' })
+      expect(formatter.extra_metadata).to eq({ 'Bar' => 'foo' })
+    end
+
+  end
+
+  describe '#initialize' do
+
+    it 'raise an error if an invalid option is given' do
+      expect {
+        SlackLogDevice::Formatter.new(foo: 'bar')
+      }.to raise_error(ArgumentError, 'Unknown key: :foo. Valid keys are: :extra_metadata')
+    end
+
+  end
+
+end

data/spec/slack_log_device_spec.rb

@@ -13,46 +13,20 @@ describe SlackLogDevice do
     expect(device).not_to be_a(Logger::LogDevice)
   end
 
-  describe '::FORMATTER' do
+  describe '.formatter' do
 
-    let(:formatter) { SlackLogDevice::FORMATTER }
-
-    it 'returns a proc' do
-      expect(formatter).to be_a(Proc)
+    it 'returns a SlackLogDevice::Formatter' do
+      expect(SlackLogDevice.formatter).to be_a(SlackLogDevice::Formatter)
     end
 
-    describe '#call' do
-
-      it 'returns a formatted message' do
-        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq('*`DEBUG`*: Hello World')
-      end
-
-      it 'includes progname if given' do
-        expect(formatter.call('DEBUG', Time.now, 'My App', 'Hello World')).to eq('*`DEBUG`* (*My App*): Hello World')
-      end
-
-      it 'formats exception' do
-        exception = RuntimeError.new('BAM!')
-        exception.set_backtrace(['foo', 'bar'])
-        expect(formatter.call('DEBUG', Time.now, nil, exception)).to eq("*`DEBUG`*: A `RuntimeError` occurred: BAM!\n\n```foo\nbar```")
-      end
-
-      it 'message with trace never exceed 4000 chars' do
-        exception = RuntimeError.new('BAM!')
-        exception.set_backtrace(['a' * 4500])
-        message = formatter.call('DEBUG', Time.now, 'My App', exception)
-        expect(message.size).to eq(4000)
-        expect(message).to end_with("aaaaaa...```")
-      end
-
-      it 'can be exactly 4000 chars (without three dots)' do
-        exception = RuntimeError.new('BAM!')
-        exception.set_backtrace(['a' * 3950])
-        message = formatter.call('DEBUG', Time.now, nil, exception)
-        expect(message).to end_with('a```')
-        expect(message.size).to eq(4000)
-      end
+    it 'block is given to formatter constructor' do
+      formatter = SlackLogDevice.formatter { |message| message.reverse }
+      expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq("*`DEBUG`*: dlroW olleH")
+    end
 
+    it 'options are forwarded to formatter constructor' do
+      formatter = SlackLogDevice.formatter(extra_metadata: { 'bar' => 'foo' })
+      expect(formatter.extra_metadata).to eq({ 'bar' => 'foo' })
     end
 
   end
@@ -186,7 +160,7 @@ describe SlackLogDevice do
       device.write('BIM!')
       expect {
         device.flush
-      }.to change { device.instance_variable_get(:@buffer) }.to([])
+      }.to change { device.instance_variable_get(:@buffer) }.to('')
       expect(HTTParty).not_to receive(:post)
       device.flush
     end
@@ -197,17 +171,17 @@ describe SlackLogDevice do
 
     it 'is true if max_buffer_size is reached' do
       options[:max_buffer_size] = 10
-      device.write('012345678')
+      device.write('0123456789')
       expect {
-        device.instance_variable_get(:@buffer).push('a')
+        device.instance_variable_get(:@buffer).send(:<<, 'a')
       }.to change { device.flush? }.from(false).to(true)
     end
 
     it 'use byte size to compare max_buffer_size' do
       options[:max_buffer_size] = 10
-      device.write('0123456é')
+      device.write('01234567é')
       expect {
-        device.instance_variable_get(:@buffer).push('a')
+        device.instance_variable_get(:@buffer).send(:<<, 'a')
       }.to change { device.flush? }.from(false).to(true)
     end
 
@@ -223,6 +197,12 @@ describe SlackLogDevice do
       }.to change { device.flush? }.from(false).to(true)
     end
 
+    it 'is true if it contains markdown code block' do
+      expect {
+        device.instance_variable_get(:@buffer).send(:<<, '```hello world```')
+      }.to change { device.flush? }.from(false).to(true)
+    end
+
   end
 
   describe '#flush_delay' do
@@ -486,12 +466,19 @@ describe SlackLogDevice do
 
     it 'strips message' do
       device.write("     BAM  !\n")
-      expect(device.instance_variable_get(:@buffer)).to eq(['BAM  !'])
+      expect(device.instance_variable_get(:@buffer)).to eq('BAM  !')
     end
 
     it 'converts message to string' do
       device.write(42)
-      expect(device.instance_variable_get(:@buffer)).to eq(['42'])
+      expect(device.instance_variable_get(:@buffer)).to eq('42')
+    end
+
+    it 'adds given string to existing buffer with a \n' do
+      device.write('BAM!')
+      expect {
+        device.write('BIM!')
+      }.to change { device.instance_variable_get(:@buffer) }.from('BAM!').to("BAM!\nBIM!")
     end
 
     it 'does nothing if message is blank' do
@@ -504,7 +491,7 @@ describe SlackLogDevice do
     it 'does nothing if message is nil' do
       expect(HTTParty).not_to receive(:post)
       expect(device.write(nil)).to be_nil
-      expect(device.instance_variable_get(:@buffer)).to eq([])
+      expect(device.instance_variable_get(:@buffer)).to eq('')
     end
 
     it 'does not post HTTP message if auto flush is false' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slack_log_device
 version: !ruby/object:Gem::Version
-  version: 2.2.3
+  version: 3.0.0
 platform: ruby
 authors:
 - Alexis Toulotte
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-24 00:00:00.000000000 Z
+date: 2017-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -124,7 +124,10 @@ files:
 - Rakefile
 - VERSION
 - lib/slack_log_device.rb
+- lib/slack_log_device/formatter.rb
+- lib/slack_log_device/rails_exceptions_logging.rb
 - slack_log_device.gemspec
+- spec/slack_log_device/formatter_spec.rb
 - spec/slack_log_device_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/alexistoulotte/slack_log_device
@@ -152,5 +155,6 @@ signing_key:
 specification_version: 4
 summary: LogDevice for Slack
 test_files:
+- spec/slack_log_device/formatter_spec.rb
 - spec/slack_log_device_spec.rb
 - spec/spec_helper.rb