buffering_logger 2.0.4 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2ec7a39f0dd57757106b2407dc76ee3a51f2efc4
-  data.tar.gz: a416626987ce0e312e1c4cd10280f280fbdc10e1
+SHA256:
+  metadata.gz: e76718294cf2d45e7d614aa99fc05574bcc21d7b1484ee8cdbcfcb9a1ee8be63
+  data.tar.gz: 936e56c62d2d5d666ec336cb5037ee96735257a16d05d35ae181e21c3141f8c5
 SHA512:
-  metadata.gz: c6c31d2d11a5144ab790dd7eb4a5b71d61a8deb8e785e6e6729fbaa636bce52e1d6f6469096e840790294f05c6a563c9aa39d1dc1197b487624cadf15eaaa4dd
-  data.tar.gz: 5783ab6b1107dd7f92f9335a314eb835a49becf524d558b2fe90a146bb140f77ca946d9d48314d0a9391f579e4d00a4c3b8ba963a36920ad0f1511c7df0f291e
+  metadata.gz: b247ee48fe4c6885ac64a8d24bccb73acda910782cbebcb5256528b35ad39f3a83c62db20dd84a76374136d9c84c861e18945f46cf6f515e107116fb18c25994
+  data.tar.gz: 3de0d002b76ea6bf7c6e48c5717364d76854a3f074932dcc76971548348a1f149468faf594de73c22813f9bfdd282030b113ba4e5816b75f42f5227daf4fff5f

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,77 @@
 # 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)
+    self.buffering = true
+    yield
+  ensure
+    self.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
 
+  def buffering
+    Thread.current[buffering_id]
   end
+
+  def buffering=(val)
+    Thread.current[buffering_id] = val
+  end
+
+  def buffering_id
+    "buffering_logger_#{object_id}_is_buffering"
+  end
+
 end

data/lib/buffering_logger/logger.rb

@@ -4,35 +4,40 @@ 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
+  include ActiveSupport::LoggerSilence if defined?(ActiveSupport::LoggerSilence)
 
-    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: nil)
-      @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/rails_rack_log_request_id.rb

@@ -0,0 +1,20 @@
+#
+# With buffered logs we don't need to log the request_id on every line.
+# Instead we log it once near the start of the request.
+# We do this via a Rack middleware to ensure that it's logged even for things
+# like a `RoutingError` or other exceptional cases.
+#
+class BufferingLogger::RailsRackLogRequestId
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    request = ActionDispatch::Request.new(env)
+    Rails.logger.info("request_id=#{request.request_id.inspect}")
+
+    @app.call(env)
+  end
+
+end

data/lib/buffering_logger/railtie.rb

@@ -1,37 +1,66 @@
 require 'buffering_logger'
 require 'buffering_logger/rack_buffer'
+require 'buffering_logger/rails_rack_log_request_id'
 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
+class BufferingLogger::Railtie < Rails::Railtie
 
-          path = app.paths["log"].first
+  def self.install(
+    transform: nil, device: nil, sync: true, request_id: true,
+    warn_log_tags: true, simple_formatter: true
+  )
+    initializer :buffering_logger, :before => :initialize_logger do |app|
+      device ||= begin
+        # Does mostly the same things that Rails does. See http://git.io/2v9FxQ
 
-          unless File.exist? File.dirname path
-            FileUtils.mkdir_p File.dirname path
-          end
+        path = app.paths["log"].first
 
-          file = File.open(path, 'a')
-          file.binmode
-          file
+        unless File.exist? File.dirname path
+          FileUtils.mkdir_p File.dirname path
         end
 
-        device.sync = true if sync && device.respond_to?(:sync=)
+        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 = if simple_formatter
+        ActiveSupport::Logger::SimpleFormatter.new
+      else
+        app.config.log_formatter
+      end
+      logger = ActiveSupport::TaggedLogging.new(logger)
 
-        logger = BufferingLogger::Logger.new(device)
-        logger.formatter = app.config.log_formatter
-        logger = ActiveSupport::TaggedLogging.new(logger)
+      app.config.logger = logger
 
-        app.config.logger = logger
+      # We insert this 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,
+      )
 
-        # 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)
+      # Log the request_id
+      if request_id
+        app.config.middleware.insert_after(
+          Rails::Rack::Logger,
+          BufferingLogger::RailsRackLogRequestId,
+        )
+      end
+
+      if warn_log_tags && app.config.log_tags.present?
+        puts(<<~TEXT.squish)
+          NOTE: You're using `Rails.application.config.log_tags` with
+          BufferingLogger. We recommend disabling these when using
+          BufferingLogger. See the README for more info.
+        TEXT
       end
     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

data/lib/buffering_logger/version.rb

@@ -0,0 +1,3 @@
+module BufferingLogger
+  VERSION = '3.1.1'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: buffering_logger
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 3.1.1
 platform: ruby
 authors:
 - Jordan Brough
@@ -22,8 +22,10 @@ files:
 - lib/buffering_logger/logger.rb
 - lib/buffering_logger/rack_buffer.rb
 - lib/buffering_logger/rails.rb
+- lib/buffering_logger/rails_rack_log_request_id.rb
 - lib/buffering_logger/railtie.rb
 - lib/buffering_logger/single_line_transform.rb
+- lib/buffering_logger/version.rb
 homepage: https://github.com/jordan-brough/buffering_logger
 licenses:
 - MIT
@@ -43,8 +45,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.1.2
 signing_key: 
 specification_version: 4
 summary: BufferingLogger is a logger that buffers log entries and then writes them