buffering_logger 2.0.5 → 2.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 243e3e793bcd45fdf09c8ae4697546f7ef1805c4
-  data.tar.gz: 4ec124f406edcca8860cfc17e8d29c6e019bebf4
+SHA256:
+  metadata.gz: 5564a270f8f8b903262a250478cfca69a7854b7943aed6e4353b7589c5bf4a3a
+  data.tar.gz: 74b1b8ac3d1d3a321c8064427966b47253c98968ba69f12fdd6e2b741989e924
 SHA512:
-  metadata.gz: 7810a492bdd74a1468a30069ff61922893fe970522d907926385b413ce673452260a33d675703d0f505a1b115f4ee9ceeba079b009292dff056e914c3ce6fa17
-  data.tar.gz: 294724ac15d92bd4337c75457fa1a72daee9202899c0fd93d86b73c921bb566db65ea9d9c84419183a8bbb9cec4e0a34a7bcebb7fde35dce04b28181da388663
+  metadata.gz: 29ed01af72ea3b3bc85446c3de71a48f2a48eed7716ff1a23c183fb8d5ba9ac9903fe969a04d8c337877562a9a0070ed1c245c27993228d05d9ae95cd876bea5
+  data.tar.gz: ef3dae1d2d911160ba538a34b03afff8a1101dbdfde68f02530547a09d4290742caa60b7b9bac874ad3c0163c830d21df1cf595ed8a0c4ee1e44c8636d4b1c16

data/lib/buffering_logger.rb

@@ -1,6 +1,6 @@
+module BufferingLogger
+end
+
 require 'buffering_logger/logger'
 require 'buffering_logger/buffer'
 require 'buffering_logger/rack_buffer'
-
-module BufferingLogger
-end

data/lib/buffering_logger/buffer.rb

@@ -1,66 +1,65 @@
 # Buffer is used to wrap the logger's logdev to accomplish buffering.
 # For the purposes of the Logger class a LogDevice only needs to implement
 # #write and #close. We add #buffered as well.
-module BufferingLogger
-  class Buffer
-    def initialize(logdev)
-      @logdev = logdev
-      @mutex = Mutex.new
-    end
+class BufferingLogger::Buffer
 
-    # buffers during the block and then flushes.
-    # returns the value of the block.
-    def buffered(transform: nil)
-      @buffering = true
-      yield
-    ensure
-      @buffering = false
-      flush(transform: transform)
-    end
+  def initialize(logdev)
+    @logdev = logdev
+    @mutex = Mutex.new
+  end
 
-    def write(msg)
-      if @buffering
-        (buffer || create_buffer).write(msg)
-      else
-        @logdev.write(msg)
-      end
-    end
+  # buffers during the block and then flushes.
+  # returns the value of the block.
+  def buffered(transform: nil)
+    @buffering = true
+    yield
+  ensure
+    @buffering = false
+    flush(transform: transform)
+  end
 
-    def close
-      @mutex.synchronize do
-        @logdev.close
-      end
+  def write(msg)
+    if @buffering
+      buffer.write(msg)
+    else
+      logdev_write(msg)
     end
+  end
 
-    private
+  def close
+    logdev_close
+  end
 
-    def flush(transform: nil)
-      if buffer && buffer.length > 0
-        @mutex.synchronize do
-          msg = buffer.string
-          msg = transform.call(msg) if transform
-          @logdev.write(msg)
-        end
-      end
-    ensure
-      unset_buffer if buffer
-    end
+  private
 
-    def buffer
-      Thread.current[buffer_id]
+  def flush(transform: nil)
+    if buffer && buffer.length > 0
+      msg = buffer.string
+      msg = transform.call(msg) if transform
+      logdev_write(msg)
     end
+  ensure
+    buffer.reopen('')
+  end
 
-    def create_buffer
-      Thread.current[buffer_id] = StringIO.new
+  def logdev_write(msg)
+    @mutex.synchronize do
+      @logdev.write(msg)
     end
+  end
 
-    def unset_buffer
-      Thread.current[buffer_id] = nil
+  def logdev_close
+    @mutex.synchronize do
+      @logdev.close
     end
+  end
 
-    def buffer_id
-      "buffering_logger_#{object_id}_buffer"
-    end
+  def buffer
+    Thread.current[buffer_id] ||= StringIO.new
+  end
 
+  def buffer_id
+    "buffering_logger_#{object_id}_buffer"
   end
+
 end

data/lib/buffering_logger/logger.rb

@@ -4,36 +4,39 @@ require 'logger'
 #   logger.buffered { logger.info 'hi'; logger.info 'goodbye' }
 # Buffering is implemented by wrapping the logger @logdev object with a Buffer.
 
-module BufferingLogger
-  class Logger < ::Logger
+class BufferingLogger::Logger < ::Logger
 
-    attr_accessor :default_transform
-    attr_reader :raw_log_device
+  attr_accessor :default_transform
+  attr_reader :raw_log_device
 
-    def initialize(logdev, shift_age: 0, shift_size: 1048576)
-      @shift_age, @shift_size = shift_age, shift_size
-      @opened_logdev = false
-      super(nil, shift_age, shift_size)
-      self.logdev = logdev
-    end
+  def initialize(logdev, shift_age: 0, shift_size: 1048576)
+    @shift_age, @shift_size = shift_age, shift_size
+    @opened_logdev = false
+    super(nil, shift_age, shift_size)
+    self.logdev = logdev
+  end
 
-    # allow changing the log destination. e.g.: in Unicorn during after_fork to
-    # set a separate log path for each worker.
-    def logdev=(logdev)
-      @logdev.close if @logdev && @opened_logdev
+  # allow changing the log destination. e.g.: in Unicorn during after_fork to
+  # set a separate log path for each worker.
+  def logdev=(logdev)
+    @logdev.close if @logdev && @opened_logdev
 
-      @raw_log_device = LogDevice.new(logdev, shift_age: @shift_age, shift_size: @shift_size)
+    @raw_log_device = LogDevice.new(
+      logdev,
+      shift_age: @shift_age,
+      shift_size: @shift_size,
+    )
 
-      # if we opened the logdev then we should close it when we're done
-      @opened_logdev = @raw_log_device.dev != logdev
+    # if we opened the logdev then we should close it when we're done
+    @opened_logdev = @raw_log_device.dev != logdev
 
-      @logdev = Buffer.new(@raw_log_device)
-    end
+    @logdev = BufferingLogger::Buffer.new(@raw_log_device)
+  end
 
-    def buffered(transform: default_transform)
-      @logdev.buffered(transform: transform) do
-        yield
-      end
+  def buffered(transform: default_transform)
+    @logdev.buffered(transform: transform) do
+      yield
     end
   end
+
 end

data/lib/buffering_logger/rack_buffer.rb

@@ -1,11 +1,11 @@
-module BufferingLogger
-  class RackBuffer
-    def initialize(app, logger, transform: nil)
-      @app, @logger, @transform = app, logger, transform
-    end
+class BufferingLogger::RackBuffer
 
-    def call(env)
-      @logger.buffered(transform: @transform) { @app.call(env) }
-    end
+  def initialize(app, logger, transform: nil)
+    @app, @logger, @transform = app, logger, transform
   end
+
+  def call(env)
+    @logger.buffered(transform: @transform) { @app.call(env) }
+  end
+
 end

data/lib/buffering_logger/railtie.rb

@@ -2,36 +2,39 @@ require 'buffering_logger'
 require 'buffering_logger/rack_buffer'
 require 'rails/railtie'
 
-module BufferingLogger
-  class Railtie < Rails::Railtie
-    def self.install(transform: nil, device: nil, sync: true)
-      initializer :buffering_logger, :before => :initialize_logger do |app|
-        device ||= begin
-          # Does mostly the same things that Rails does. See http://git.io/2v9FxQ
-
-          path = app.paths["log"].first
-
-          unless File.exist? File.dirname path
-            FileUtils.mkdir_p File.dirname path
-          end
-
-          file = File.open(path, 'a')
-          file.binmode
-          file
-        end
+class BufferingLogger::Railtie < Rails::Railtie
 
-        device.sync = true if sync && device.respond_to?(:sync=)
+  def self.install(transform: nil, device: nil, sync: true)
+    initializer :buffering_logger, :before => :initialize_logger do |app|
+      device ||= begin
+        # Does mostly the same things that Rails does. See http://git.io/2v9FxQ
 
-        logger = BufferingLogger::Logger.new(device)
-        logger.formatter = app.config.log_formatter
-        logger = ActiveSupport::TaggedLogging.new(logger)
+        path = app.paths["log"].first
 
-        app.config.logger = logger
+        unless File.exist? File.dirname path
+          FileUtils.mkdir_p File.dirname path
+        end
 
-        # Inserts at the very beginning so that all logs, even from other
-        # middleware, get buffered together.
-        app.config.middleware.insert(0, BufferingLogger::RackBuffer, logger, transform: transform)
+        file = File.open(path, 'a')
+        file.binmode
+        file
       end
+
+      device.sync = true if sync && device.respond_to?(:sync=)
+
+      logger = BufferingLogger::Logger.new(device)
+      logger.formatter = app.config.log_formatter
+      logger = ActiveSupport::TaggedLogging.new(logger)
+
+      app.config.logger = logger
+
+      # Inserts at the very beginning so that all logs, even from other
+      # middleware, get buffered together.
+      app.config.middleware.insert(
+        0,
+        BufferingLogger::RackBuffer, logger, transform: transform,
+      )
     end
   end
+
 end

data/lib/buffering_logger/single_line_transform.rb

@@ -1,28 +1,28 @@
-module BufferingLogger
-  # This transforms a multiline log into a single line log by replacing newlines
-  # with a special string (a single space by default).
-  #
-  # This is useful for platforms like Heroku where multiline Rails request logs
-  # of one process are interwoven with the request logs of other processes and
-  # other log sources (like the Heroku router).
-  #
-  # If you want to convert newlines into a special string so that you can later
-  # turn them back into newlines (e.g. in Splunk using a
-  # [SEDCMD](http://docs.splunk.com/Documentation/Splunk/latest/admin/Propsconf))
-  # then you can supply a `replacement` argument.
-  class SingleLineTransform
-    REPLACEMENT = ' '.freeze
-    NEWLINE = /\r?\n/.freeze
+# This transforms a multiline log into a single line log by replacing newlines
+# with a special string (a single space by default).
+#
+# This is useful for platforms like Heroku where multiline Rails request logs
+# of one process are interwoven with the request logs of other processes and
+# other log sources (like the Heroku router).
+#
+# If you want to convert newlines into a special string so that you can later
+# turn them back into newlines (e.g. in Splunk using a
+# [SEDCMD](http://docs.splunk.com/Documentation/Splunk/latest/admin/Propsconf))
+# then you can supply a `replacement` argument.
+class BufferingLogger::SingleLineTransform
 
-    def initialize(replacement: REPLACEMENT)
-      @replacement = replacement
-    end
+  REPLACEMENT = ' '.freeze
+  NEWLINE = /\r?\n/.freeze
 
-    def call(msg)
-      msg = msg.dup
-      msg.strip!
-      msg.gsub!(NEWLINE, @replacement)
-      msg << "\n"
-    end
+  def initialize(replacement: REPLACEMENT)
+    @replacement = replacement
   end
+
+  def call(msg)
+    msg = msg.dup
+    msg.strip!
+    msg.gsub!(NEWLINE, @replacement)
+    msg << "\n"
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: buffering_logger
 version: !ruby/object:Gem::Version
-  version: 2.0.5
+  version: 2.0.6
 platform: ruby
 authors:
 - Jordan Brough
@@ -43,8 +43,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: BufferingLogger is a logger that buffers log entries and then writes them