slack_log_device 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a971af4091c07ffdc8b9ee83c180160eadf73352
-  data.tar.gz: b6595e5dfd101fedb0fece93e7cd45b25406996a
+  metadata.gz: 3567b60b8adf372370ebeff154732ea9c0c85a6b
+  data.tar.gz: 1eaa0fea7a5ce04b969ef5ee2c5fd806e558d822
 SHA512:
-  metadata.gz: 00c9b7b2007d08c6a2f5471a74d454fd12a52789e4d7b3a64c71bbfa182903ae43200d4349185a10afee3676c2a676a6d5e6cf6751d364e9c0c108e47cc03c48
-  data.tar.gz: 95513c23e9c1dc1cd09f66a8839c4a26400fea2a1ae146f23041c9e47542707a09a5d48b1b3d330b44b84a63872443a380169a7ac957ce1cc4f1f3ac190752ee
+  metadata.gz: 721424872c5fbb4f9a997ef2c10b2c35f917255062fe469db09d7cf417295396ff955c23bfa1b7bcd827c5881a060c6e0c8bc157a633a8f8f9a66df9db88d08f
+  data.tar.gz: bd94f833858783c0ea6c4b649ea1a9cb7610302cf36e49cf9e42f2ebf4d0783d1c567061b70c0b282cc7ea8a6f5e51d8041d6ac0bc241a0406c3af3fc600bb9b

data/.gitignore

@@ -1,5 +1,6 @@
 .DS_Store
 /.bundle/
+/.byebug_history
 /.ruby-version
 /Gemfile.lock
 /pkg/

data/README.mdown

@@ -24,6 +24,19 @@ logger.warn('BAM!')
 
 Then, the logged message will be writen to webhook's configured channel.
 
+Note that the messages written are buffered in order to avoid consecutive
+request.
+
+## Options
+
+- `auto_flush`: To flush messages directly when a message is written (disabled
+by default).
+- `flush_delay`: The delay in seconds to flush messages (1 by default).
+- `max_buffer_size`: The max buffer size to flush messages (8192 by default).
+- `timeout`: The timeout in seconds to send message to slack (5 by default).
+- `username`: The username to post message as (nil by default).
+- `webhook_url`: The URL of the webhook (mandatory).
+
 ## Executing test suite
 
 This project is fully tested with [Rspec 3](http://github.com/rspec/rspec).

data/VERSION

@@ -1 +1 @@
-1.0.1
+2.0.0

data/lib/slack_log_device.rb

@@ -5,22 +5,69 @@ require 'logger'
 
 class SlackLogDevice
 
-  attr_reader :timeout, :username, :webhook_url
+  attr_reader :flush_delay, :max_buffer_size, :timeout, :username, :webhook_url
 
   def initialize(options = {})
-    options.assert_valid_keys(:timeout, :username, :webhook_url)
+    options.assert_valid_keys(:auto_flush, :flush_delay, :max_buffer_size, :timeout, :username, :webhook_url)
+    @buffer = []
+    @mutex = Mutex.new
+    @flush_thread
+    self.auto_flush = options[:auto_flush]
+    self.flush_delay = options.key?(:flush_delay) ? options[:flush_delay] : 1
+    self.max_buffer_size = options.key?(:max_buffer_size) ? options[:max_buffer_size] : 8192
     self.timeout = options.key?(:timeout) ? options[:timeout] : 5
     self.username = options[:username]
     self.webhook_url = options[:webhook_url]
   end
 
+  def auto_flush?
+    @auto_flush
+  end
+
+  def auto_flush=(value)
+    @auto_flush = value.present?
+  end
+
   def close
     # Does nothing, this method must exist to consider the LogDevice as an IO.
   end
 
+  def flush
+    return if @buffer.empty?
+    message = ''
+    @mutex.synchronize do
+      message = @buffer.join("\n")
+      @buffer.clear
+    end
+    data = { 'text' => message.to_s }
+    data['username'] = username if username.present?
+    begin
+      HTTParty.post(webhook_url, body: data.to_json, headers: { 'Content-Type': 'application/json' }, timeout: timeout)
+    rescue => e
+      STDERR.puts(e)
+    end
+    nil
+  end
+
+  def flush?
+    auto_flush? || flush_delay.zero? || @buffer.join("\n").size > max_buffer_size
+  end
+
+  def flush_delay=(value)
+    delay = Integer(value) rescue nil
+    raise ArgumentError.new("Invalid flush delay: #{value.inspect}") if delay.nil? || delay < 0
+    @flush_delay = delay
+  end
+
+  def max_buffer_size=(value)
+    size = Integer(value) rescue nil
+    raise ArgumentError.new("Invalid max buffer size: #{value.inspect}") if size.nil? || size < 0
+    @max_buffer_size = size
+  end
+
   def timeout=(value)
     timeout = Integer(value) rescue nil
-    raise ArgumentError.new("Invalid timeout: #{value.inspect}") if timeout.nil?
+    raise ArgumentError.new("Invalid timeout: #{value.inspect}") if timeout.nil? || timeout <= 0
     @timeout = timeout
   end
 
@@ -31,16 +78,25 @@ class SlackLogDevice
   def webhook_url=(value)
     raise ArgumentError.new('Webhook URL must be specified') if value.blank?
     uri = URI(value.to_s) rescue nil
-    raise ArgumentError.new("Invalid Webhook URL: #{value.inspect}") if uri.nil? || !uri.is_a?(URI::HTTP)
+    raise ArgumentError.new("Invalid webhook URL: #{value.inspect}") if uri.nil? || !uri.is_a?(URI::HTTP)
     @webhook_url = uri.to_s
   end
 
   def write(message)
     message = message.to_s.try(:strip)
     return if message.blank?
-    data = { 'text' => message.to_s }
-    data['username'] = username if username.present?
-    HTTParty.post(webhook_url, body: data.to_json, headers: { 'Content-Type': 'application/json' }, timeout: timeout)
+    @mutex.synchronize do
+      @buffer << message
+    end
+    if flush?
+      flush
+    else
+      @flush_thread.kill if @flush_thread
+      @flush_thread = Thread.new do
+        sleep(flush_delay)
+        flush
+      end
+    end
     nil
   end
 

data/spec/slack_log_device_spec.rb

@@ -6,6 +6,24 @@ describe SlackLogDevice do
   let(:logger) { Logger.new(device).tap { |logger| logger.level = Logger::INFO } }
   let(:options) { { username: 'MyApp', webhook_url: 'https://hooks.slack.com/services/test' } }
 
+  before :each do
+    allow(HTTParty).to receive(:post)
+  end
+
+  describe '#auto_flush?' do
+
+    it 'is false by default' do
+      options.delete(:auto_flush)
+      expect(device).not_to be_auto_flush
+    end
+
+    it 'can be set to true' do
+      options[:auto_flush] = true
+      expect(device).to be_auto_flush
+    end
+
+  end
+
   describe '#close' do
 
     it 'does nothing' do
@@ -16,12 +34,128 @@ describe SlackLogDevice do
 
   end
 
+  describe '#flush' do
+
+    it 'sends a post to webhook URL with given given message and specified username' do
+      device.write('BAM!')
+      expect(HTTParty).to receive(:post).with(options[:webhook_url], body: { 'text' => 'BAM!', 'username' => options[:username] }.to_json, headers: { 'Content-Type':  'application/json' }, timeout: 5)
+      device.flush
+    end
+
+    it 'does not send username if nil' do
+      options.delete(:username)
+      device.write('BAM!')
+      expect(HTTParty).to receive(:post).with(options[:webhook_url], body: { 'text' => 'BAM!' }.to_json, headers: { 'Content-Type':  'application/json' }, timeout: 5)
+      device.flush
+    end
+
+    it 'use specified timeout' do
+      options[:timeout] = 12
+      device.write('BAM!')
+      expect(HTTParty).to receive(:post).with(options[:webhook_url], body: { 'text' => 'BAM!', 'username' => options[:username] }.to_json, headers: { 'Content-Type':  'application/json' }, timeout: 12)
+      device.flush
+    end
+
+    it 'flushes all message writen separated by a new line' do
+      device.write('BAM!')
+      device.write('BIM!')
+      expect(HTTParty).to receive(:post).with(options[:webhook_url], body: { 'text' => "BAM!\nBIM!", 'username' => options[:username] }.to_json, headers: { 'Content-Type':  'application/json' }, timeout: 5)
+      device.flush
+    end
+
+    it 'returns nil' do
+      device.write('BIM!')
+      expect(device.flush).to be_nil
+    end
+
+  end
+
+  describe '#flush?' do
+
+    it 'is true if max_buffer_size is reached' do
+      options[:max_buffer_size] = 10
+      device.write('012345678')
+      expect {
+        device.instance_variable_get(:@buffer).push('a')
+      }.to change { device.flush? }.from(false).to(true)
+    end
+
+    it 'is true if auto_flush option is present' do
+      expect {
+        device.auto_flush = true
+      }.to change { device.flush? }.from(false).to(true)
+    end
+
+    it 'is true if flush delay is 0' do
+      expect {
+        device.flush_delay = 0
+      }.to change { device.flush? }.from(false).to(true)
+    end
+
+  end
+
+  describe '#flush_delay' do
+
+    it 'is 1 by default' do
+      expect(device.flush_delay).to eq(1)
+    end
+
+    it 'can be specified' do
+      options[:flush_delay] = 10
+      expect(device.flush_delay).to be(10)
+    end
+
+    it 'raise an error if invalid' do
+      options[:flush_delay] = 'foo'
+      expect {
+        device
+      }.to raise_error(ArgumentError, 'Invalid flush delay: "foo"')
+    end
+
+    it 'raise an error if negative' do
+      options[:flush_delay] = -1
+      expect {
+        device
+      }.to raise_error(ArgumentError, 'Invalid flush delay: -1')
+    end
+
+    it 'can be zero' do
+      options[:flush_delay] = 0
+      expect(device.flush_delay).to be(0)
+    end
+
+    it 'raise an error if blank' do
+      options[:flush_delay] = ' '
+      expect {
+        device
+      }.to raise_error(ArgumentError, 'Invalid flush delay: " "')
+    end
+
+    it 'raise an error if set as nil' do
+      expect {
+        device.flush_delay = nil
+      }.to raise_error(ArgumentError, 'Invalid flush delay: nil')
+    end
+
+    it 'can be specified as string' do
+      options[:flush_delay] = '42'
+      expect(device.flush_delay).to eq(42)
+    end
+
+    it 'can be set' do
+      expect {
+        device.flush_delay = 15
+      }.to change { device.flush_delay }.from(1).to(15)
+    end
+
+  end
+
   describe '#initialize' do
 
     it 'raise an error if an invalid option is given' do
       expect {
         SlackLogDevice.new(foo: 'bar')
-      }.to raise_error(ArgumentError, "Unknown key: :foo. Valid keys are: :timeout, :username, :webhook_url")
+      }.to raise_error(ArgumentError, "Unknown key: :foo. Valid keys are: :auto_flush, :flush_delay, :max_buffer_size, :timeout, :username, :webhook_url")
     end
 
     it 'raise an error if webhook option is not given' do
@@ -32,6 +166,62 @@ describe SlackLogDevice do
 
   end
 
+  describe '#max_buffer_size' do
+
+    it 'is 8192 by default' do
+      expect(device.max_buffer_size).to eq(8192)
+    end
+
+    it 'can be specified' do
+      options[:max_buffer_size] = 42
+      expect(device.max_buffer_size).to be(42)
+    end
+
+    it 'raise an error if invalid' do
+      options[:max_buffer_size] = 'foo'
+      expect {
+        device
+      }.to raise_error(ArgumentError, 'Invalid max buffer size: "foo"')
+    end
+
+    it 'raise an error if negative' do
+      options[:max_buffer_size] = -1
+      expect {
+        device
+      }.to raise_error(ArgumentError, 'Invalid max buffer size: -1')
+    end
+
+    it 'can be zero' do
+      options[:max_buffer_size] = 0
+      expect(device.max_buffer_size).to be_zero
+    end
+
+    it 'raise an error if blank' do
+      options[:max_buffer_size] = ' '
+      expect {
+        device
+      }.to raise_error(ArgumentError, 'Invalid max buffer size: " "')
+    end
+
+    it 'raise an error if set as nil' do
+      expect {
+        device.max_buffer_size = nil
+      }.to raise_error(ArgumentError, 'Invalid max buffer size: nil')
+    end
+
+    it 'can be specified as string' do
+      options[:max_buffer_size] = '42'
+      expect(device.max_buffer_size).to eq(42)
+    end
+
+    it 'can be set' do
+      expect {
+        device.max_buffer_size = 1024
+      }.to change { device.max_buffer_size }.from(8192).to(1024)
+    end
+
+  end
+
   describe '#timeout' do
 
     it 'is 5 by default' do
@@ -50,7 +240,21 @@ describe SlackLogDevice do
       }.to raise_error(ArgumentError, 'Invalid timeout: "foo"')
     end
 
-    it 'is default value if blank' do
+    it 'raise an error if negative' do
+      options[:timeout] = -1
+      expect {
+        device
+      }.to raise_error(ArgumentError, 'Invalid timeout: -1')
+    end
+
+    it 'raise an error if zero' do
+      options[:timeout] = 0
+      expect {
+        device
+      }.to raise_error(ArgumentError, 'Invalid timeout: 0')
+    end
+
+    it 'raise an error if blank' do
       options[:timeout] = ' '
       expect {
         device
@@ -115,7 +319,7 @@ describe SlackLogDevice do
       options[:webhook_url] = 'foo'
       expect {
         device
-      }.to raise_error(ArgumentError, 'Invalid Webhook URL: "foo"')
+      }.to raise_error(ArgumentError, 'Invalid webhook URL: "foo"')
     end
 
     it 'can be an HTTP URL' do
@@ -132,7 +336,7 @@ describe SlackLogDevice do
       options[:webhook_url] = 'ftp://google.com'
       expect {
         device
-      }.to raise_error(ArgumentError, 'Invalid Webhook URL: "ftp://google.com"')
+      }.to raise_error(ArgumentError, 'Invalid webhook URL: "ftp://google.com"')
     end
 
     it 'can be set' do
@@ -145,35 +349,18 @@ describe SlackLogDevice do
 
   describe '#write' do
 
-    it 'sends a post to webhook URL with given given message and specified username' do
-      expect(HTTParty).to receive(:post).with(options[:webhook_url], body: { 'text' => 'BAM!', 'username' => options[:username] }.to_json, headers: { 'Content-Type':  'application/json' }, timeout: 5)
-      device.write('BAM!')
-    end
-
     it 'returns nil' do
-      allow(HTTParty).to receive(:post)
       expect(device.write('BAM!')).to be_nil
     end
 
-    it 'does not send username if nil' do
-      options.delete(:username)
-      expect(HTTParty).to receive(:post).with(options[:webhook_url], body: { 'text' => 'BAM!' }.to_json, headers: { 'Content-Type':  'application/json' }, timeout: 5)
-      device.write('BAM!')
-    end
-
     it 'does nothing if log level is lower than specified one' do
       expect(HTTParty).not_to receive(:post)
       logger.debug('BIM!')
     end
 
-    it 'send HTTP request if log level is equal to specified one' do
-      expect(HTTParty).to receive(:post)
-      logger.info('BIM!')
-    end
-
     it 'strips message' do
-      expect(HTTParty).to receive(:post).with(options[:webhook_url], body: { 'text' => 'BAM  !', 'username' => options[:username] }.to_json, headers: { 'Content-Type':  'application/json' }, timeout: 5)
       device.write("     BAM  !\n")
+      expect(device.instance_variable_get(:@buffer)).to eq(['BAM  !'])
     end
 
     it 'does nothing if message is blank' do
@@ -184,16 +371,29 @@ 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([])
+    end
+
+    it 'send HTTP request if log level is equal to specified one' do
+      expect(HTTParty).to receive(:post)
+      logger.info('BIM!')
+      device.flush
     end
 
     it 'send HTTP request if log level is higher to specified one' do
       expect(HTTParty).to receive(:post)
       logger.warn('BIM!')
+      device.flush
     end
 
-    it 'use specified timeout' do
-      options[:timeout] = 12
-      expect(HTTParty).to receive(:post).with(options[:webhook_url], body: { 'text' => 'BAM!', 'username' => options[:username] }.to_json, headers: { 'Content-Type':  'application/json' }, timeout: 12)
+    it 'flush if auto flush is true' do
+      options[:auto_flush] = true
+      expect(HTTParty).to receive(:post)
+      device.write('BAM!')
+    end
+
+    it 'does not post HTTP message if auto flush is false' do
+      expect(HTTParty).not_to receive(:post)
       device.write('BAM!')
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slack_log_device
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Alexis Toulotte