timber 2.0.24 → 2.1.0.rc1

data/lib/timber/log_entry.rb

@@ -1,5 +1,8 @@
 require 'socket'
 
+require "timber/contexts"
+require "timber/events"
+
 module Timber
   # Represents a new log entry into the log. This is an intermediary class between
   # `Logger` and the log device that you set it up with.
@@ -32,6 +35,9 @@ module Timber
       @time_ms = options[:time_ms]
 
       context_snapshot = {} if context_snapshot.nil?
+
+      # Set the system context for each log entry since processes can be forked
+      # and the process ID could change.
       hostname = Socket.gethostname
       pid = Process.pid
       system_context = Contexts::System.new(hostname: hostname, pid: pid)
@@ -41,10 +47,16 @@ module Timber
       @event = event
     end
 
+    # Builds a hash representation of containing simply objects, suitable for serialization.
     def as_json(options = {})
       options ||= {}
-      hash = {:level => level, :dt => formatted_dt, :message => message, :tags => tags,
-        :time_ms => time_ms}
+      hash = {
+        :level => level,
+        :dt => formatted_dt,
+        :message => message,
+        :tags => tags,
+        :time_ms => time_ms
+      }
 
       if !event.nil?
         hash[:event] = event.as_json

data/lib/timber/logger.rb

@@ -1,6 +1,11 @@
 require "logger"
 require "msgpack"
 
+require "timber/current_context"
+require "timber/event"
+require "timber/log_devices/http"
+require "timber/log_entry"
+
 module Timber
   # The Timber Logger behaves exactly like `::Logger`, except that it supports a transparent API
   # for logging structured messages. It ensures your log messages are communicated properly
@@ -72,47 +77,49 @@ module Timber
         "FATAL" => :fatal,
         "UNKNOWN" => :unknown
       }
+      EMPTY_ARRAY = []
 
       private
-        def build_log_entry(severity, time, progname, msg)
-          level = SEVERITY_MAP.fetch(severity)
+        def build_log_entry(severity, time, progname, logged_obj)
           context_snapshot = CurrentContext.instance.snapshot
-
+          level = SEVERITY_MAP.fetch(severity)
           tags = extract_active_support_tagged_logging_tags
-          time_ms = nil
-          if msg.is_a?(Hash)
-            if msg.key?(:tag) || msg.key?(:tags)
-              tags = tags.clone
-              tags << msg.delete(:tag) if msg.key?(:tag)
-              tags += msg.delete(:tags) if msg.key?(:tags)
-              tags.uniq!
-            end
-            time_ms = msg.delete(:time_ms) if msg.key?(:time_ms)
-
-            msg = msg[:message] if msg.length == 1
-          end
 
-          event = Events.build(msg)
+          if logged_obj.is_a?(Event)
+            LogEntry.new(level, time, progname, logged_obj.message, context_snapshot, logged_obj,
+              tags: tags)
+          elsif logged_obj.is_a?(Hash)
+            # Extract the tags
+            tags = tags.clone
+            tags << logged_obj.delete(:tag) if logged_obj.key?(:tag)
+            tags += logged_obj.delete(:tags) if logged_obj.key?(:tags)
+            tags.uniq!
+
+            # Extract the time_ms
+            time_ms = logged_obj.delete(:time_ms)
 
-          if event
-            LogEntry.new(level, time, progname, event.message, context_snapshot, event, tags: tags, time_ms: time_ms)
+            # Build the event
+            event = Events.build(logged_obj)
+            message = event ? event.message : logged_obj[:message]
+
+            LogEntry.new(level, time, progname, message, context_snapshot, event, tags: tags,
+              time_ms: time_ms)
           else
-            LogEntry.new(level, time, progname, msg, context_snapshot, nil, tags: tags, time_ms: time_ms)
+            LogEntry.new(level, time, progname, logged_obj, context_snapshot, nil, tags: tags)
           end
         end
 
-        # Because of all the crazy ways Rails has attempted this we need this crazy method.
+        # Because of all the crazy ways Rails has attempted tags, we need this crazy method.
         def extract_active_support_tagged_logging_tags
           Thread.current[:activesupport_tagged_logging_tags] ||
             Thread.current["activesupport_tagged_logging_tags:#{object_id}"] ||
-            []
+            EMPTY_ARRAY
         end
     end
 
     # For use in development and test environments where you do not want metadata
     # included in the log lines.
-    class SimpleFormatter < Formatter
-
+    class MessageOnlyFormatter < Formatter
       # This method is invoked when a log event occurs
       def call(severity, timestamp, progname, msg)
         log_entry = build_log_entry(severity, timestamp, progname, msg)
@@ -127,19 +134,17 @@ module Timber
     #
     #   My log message @metadata {"level":"info","dt":"2016-09-01T07:00:00.000000-05:00"}
     #
-    class StringFormatter < Formatter
-      METADATA_CALLOUT = "@metadata".freeze
+    class AugmentedFormatter < Formatter
+      METADATA_CALLOUT = " @metadata ".freeze
+      NEW_LINE = "\n".freeze
+      ESCAPED_NEW_LINE = "\\n".freeze
 
       def call(severity, time, progname, msg)
         log_entry = build_log_entry(severity, time, progname, msg)
-
-        if Config.instance.append_metadata?
-          metadata = log_entry.to_json(:except => [:message])
-          # use << for concatenation for performance reasons
-          log_entry.message.gsub("\n", "\\n") << " " << METADATA_CALLOUT << " " << metadata << "\n"
-        else
-          log_entry.message + "\n"
-        end
+        metadata = log_entry.to_json(:except => [:message])
+        # use << for concatenation for performance reasons
+        log_entry.message.gsub(NEW_LINE, ESCAPED_NEW_LINE) << METADATA_CALLOUT <<
+          metadata << NEW_LINE
       end
     end
 
@@ -176,7 +181,7 @@ module Timber
     include ::LoggerSilence if defined?(::LoggerSilence)
 
     # Creates a new Timber::Logger instances. Accepts the same arguments as `::Logger.new`.
-    # The only difference is that it default the formatter to {HybridFormatter}. Using
+    # The only difference is that it default the formatter to {AugmentedFormatter}. Using
     # a different formatter is easy. For example, if you prefer your logs in JSON.
     #
     # @example Changing your formatter
@@ -193,7 +198,7 @@ module Timber
       if args.size == 1 and args.first.is_a?(LogDevices::HTTP)
         self.formatter = PassThroughFormatter.new
       else
-        self.formatter = StringFormatter.new
+        self.formatter = AugmentedFormatter.new
       end
 
       self.level = environment_level
@@ -203,6 +208,9 @@ module Timber
       @initialized = true
     end
 
+    # Sets a new formatted on the logger.
+    #
+    # @note The formatter cannot be changed if you are using the HTTP logger backend.
     def formatter=(value)
       if @initialized && @logdev && @logdev.dev.is_a?(Timber::LogDevices::HTTP) && !value.is_a?(PassThroughFormatter)
         raise ArgumentError.new("The formatter cannot be changed when using the " +
@@ -219,6 +227,13 @@ module Timber
       Timber::CurrentContext.with(context, &block)
     end
 
+    # Patch to ensure that the {#level} method is used instead of `@level`.
+    # This is required because of Rails' monkey patching on Logger via `::LoggerSilence`.
+    def add(severity, message = nil, progname = nil, &block)
+      return true if @logdev.nil? || (severity || UNKNOWN) < level
+      super
+    end
+
     # Backwards compatibility with older ActiveSupport::Logger versions
     Logger::Severity.constants.each do |severity|
       class_eval(<<-EOT, __FILE__, __LINE__ + 1)
@@ -226,7 +241,7 @@ module Timber
           progname = args.first
           options = args.last
 
-          if args.length == 2 and options.is_a?(Hash) && options != {}
+          if args.length == 2 and options.is_a?(Hash) && options.length > 0
             progname = options.merge(message: progname)
           end
 

data/lib/timber/overrides.rb

@@ -1,3 +1,5 @@
+# The order is relevant
+require "timber/overrides/active_support_3_tagged_logging"
 require "timber/overrides/active_support_tagged_logging"
 require "timber/overrides/lograge"
 require "timber/overrides/rails_stdout_logging"

data/lib/timber/overrides/active_support_3_tagged_logging.rb

@@ -0,0 +1,103 @@
+# This patch is specifically for Rails 3. The legacy approach to wrapping the logger in
+# ActiveSupport::TaggedLogging is rather poor, hence the reason it was changed entirely
+# for Rails 4 and 5. The problem is that ActiveSupport::TaggedLogging is a wrapping
+# class that entirely redefines the public API for the logger. As a result, any deviations
+# from this API in the logger are not exposed (such as accepting event data as a second argument).
+# This is assuming, so we're fixing it here.
+
+begin
+  require "active_support/tagged_logging"
+
+  # Instead of patching the class we're pulling the code from Rails master. This brings in
+  # a number of improvements while also addressing the issue above.
+  if ActiveSupport::TaggedLogging.instance_of?(Class)
+    ActiveSupport.send(:remove_const, :TaggedLogging)
+
+    require "active_support/core_ext/module/delegation"
+    require "active_support/core_ext/object/blank"
+    require "logger"
+
+    module ActiveSupport
+      # Wraps any standard Logger object to provide tagging capabilities.
+      #
+      #   logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
+      #   logger.tagged('BCX') { logger.info 'Stuff' }                            # Logs "[BCX] Stuff"
+      #   logger.tagged('BCX', "Jason") { logger.info 'Stuff' }                   # Logs "[BCX] [Jason] Stuff"
+      #   logger.tagged('BCX') { logger.tagged('Jason') { logger.info 'Stuff' } } # Logs "[BCX] [Jason] Stuff"
+      #
+      # This is used by the default Rails.logger as configured by Railties to make
+      # it easy to stamp log lines with subdomains, request ids, and anything else
+      # to aid debugging of multi-user production applications.
+      module TaggedLogging
+        module Formatter # :nodoc:
+          # This method is invoked when a log event occurs.
+          def call(severity, timestamp, progname, msg)
+            super(severity, timestamp, progname, "#{tags_text}#{msg}")
+          end
+
+          def tagged(*tags)
+            new_tags = push_tags(*tags)
+            yield self
+          ensure
+            pop_tags(new_tags.size)
+          end
+
+          def push_tags(*tags)
+            tags.flatten.reject(&:blank?).tap do |new_tags|
+              current_tags.concat new_tags
+            end
+          end
+
+          def pop_tags(size = 1)
+            current_tags.pop size
+          end
+
+          def clear_tags!
+            current_tags.clear
+          end
+
+          def current_tags
+            # We use our object ID here to avoid conflicting with other instances
+            thread_key = @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}".freeze
+            Thread.current[thread_key] ||= []
+          end
+
+          def tags_text
+            tags = current_tags
+            if tags.any?
+              tags.collect { |tag| "[#{tag}] " }.join
+            end
+          end
+        end
+
+        # Simple formatter which only displays the message.
+        class SimpleFormatter < ::Logger::Formatter
+          # This method is invoked when a log event occurs
+          def call(severity, timestamp, progname, msg)
+            "#{String === msg ? msg : msg.inspect}\n"
+          end
+        end
+
+        def self.new(logger)
+          # Ensure we set a default formatter so we aren't extending nil!
+          logger.formatter ||= SimpleFormatter.new
+          logger.formatter.extend Formatter
+          logger.extend(self)
+        end
+
+        delegate :push_tags, :pop_tags, :clear_tags!, to: :formatter
+
+        def tagged(*tags)
+          formatter.tagged(*tags) { yield self }
+        end
+
+        def flush
+          clear_tags!
+          super if defined?(super)
+        end
+      end
+    end
+  end
+
+rescue Exception
+end

data/lib/timber/overrides/active_support_tagged_logging.rb

@@ -1,103 +1,66 @@
-# This patch is specifically for Rails 3. The legacy approach to wrapping the logger in
-# ActiveSupport::TaggedLogging is rather poor, hence the reason it was changed entirely
-# for Rails 4 and 5. The problem is that ActiveSupport::TaggedLogging is a wrapping
-# class that entirely redefines the public API for the logger. As a result, any deviations
-# from this API in the logger are not exposed (such as accepting event data as a second argument).
-# This is assuming, so we're fixing it here.
-
-begin
-  require "active_support/tagged_logging"
-
-  # Instead of patching the class we're pulling the code from Rails master. This brings in
-  # a number of improvements while also addressing the issue above.
-  if ActiveSupport::TaggedLogging.instance_of?(Class)
-    ActiveSupport.send(:remove_const, :TaggedLogging)
-
-    require "active_support/core_ext/module/delegation"
-    require "active_support/core_ext/object/blank"
-    require "logger"
-
-    module ActiveSupport
-      # Wraps any standard Logger object to provide tagging capabilities.
-      #
-      #   logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
-      #   logger.tagged('BCX') { logger.info 'Stuff' }                            # Logs "[BCX] Stuff"
-      #   logger.tagged('BCX', "Jason") { logger.info 'Stuff' }                   # Logs "[BCX] [Jason] Stuff"
-      #   logger.tagged('BCX') { logger.tagged('Jason') { logger.info 'Stuff' } } # Logs "[BCX] [Jason] Stuff"
-      #
-      # This is used by the default Rails.logger as configured by Railties to make
-      # it easy to stamp log lines with subdomains, request ids, and anything else
-      # to aid debugging of multi-user production applications.
-      module TaggedLogging
-        module Formatter # :nodoc:
-          # This method is invoked when a log event occurs.
-          def call(severity, timestamp, progname, msg)
-            super(severity, timestamp, progname, "#{tags_text}#{msg}")
-          end
-
-          def tagged(*tags)
-            new_tags = push_tags(*tags)
-            yield self
-          ensure
-            pop_tags(new_tags.size)
-          end
-
-          def push_tags(*tags)
-            tags.flatten.reject(&:blank?).tap do |new_tags|
-              current_tags.concat new_tags
+# This is an override instead of an integration because without this Timber would not
+# work properly if ActiveSupport::TaggedLogging is used.
+#
+# This is called after 'active_support_3_tagged_logging' where the constant is loaded and
+# replaced. I want to make sure we don't attempt to load it again undoing the patches
+# applied there.
+if defined?(ActiveSupport::TaggedLogging)
+  module Timber
+    module Overrides
+      # @private
+      module ActiveSupportTaggedLogging
+        # @private
+        module FormatterMethods
+          def self.included(mod)
+            mod.module_eval do
+              alias_method :_timber_original_push_tags, :push_tags
+              alias_method :_timber_original_pop_tags, :pop_tags
+
+              def call(severity, timestamp, progname, msg)
+                if is_a?(Timber::Logger::Formatter)
+                  # Don't convert the message into a string
+                  super(severity, timestamp, progname, msg)
+                else
+                  super(severity, timestamp, progname, "#{tags_text}#{msg}")
+                end
+              end
             end
           end
+        end
 
-          def pop_tags(size = 1)
-            current_tags.pop size
-          end
-
-          def clear_tags!
-            current_tags.clear
-          end
-
-          def current_tags
-            # We use our object ID here to avoid conflicting with other instances
-            thread_key = @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}".freeze
-            Thread.current[thread_key] ||= []
-          end
-
-          def tags_text
-            tags = current_tags
-            if tags.any?
-              tags.collect { |tag| "[#{tag}] " }.join
+        # @private
+        module LoggerMethods
+          def self.included(klass)
+            klass.class_eval do
+              def add(severity, message = nil, progname = nil, &block)
+                if message.nil?
+                  if block_given?
+                    message = block.call
+                  else
+                    message = progname
+                    progname = nil #No instance variable for this like Logger
+                  end
+                end
+                if @logger.is_a?(Timber::Logger)
+                  @logger.add(severity, message, progname)
+                else
+                  @logger.add(severity, "#{tags_text}#{message}", progname)
+                end
+              end
             end
           end
         end
 
-        # Simple formatter which only displays the message.
-        class SimpleFormatter < ::Logger::Formatter
-          # This method is invoked when a log event occurs
-          def call(severity, timestamp, progname, msg)
-            "#{String === msg ? msg : msg.inspect}\n"
+        if defined?(::ActiveSupport::TaggedLogging::Formatter)
+          if !::ActiveSupport::TaggedLogging::Formatter.include?(FormatterMethods)
+            ::ActiveSupport::TaggedLogging::Formatter.send(:include, FormatterMethods)
+          end
+        else
+          if !::ActiveSupport::TaggedLogging.include?(LoggerMethods)
+            ::ActiveSupport::TaggedLogging.send(:include, LoggerMethods)
           end
-        end
-
-        def self.new(logger)
-          # Ensure we set a default formatter so we aren't extending nil!
-          logger.formatter ||= SimpleFormatter.new
-          logger.formatter.extend Formatter
-          logger.extend(self)
-        end
-
-        delegate :push_tags, :pop_tags, :clear_tags!, to: :formatter
-
-        def tagged(*tags)
-          formatter.tagged(*tags) { yield self }
-        end
-
-        def flush
-          clear_tags!
-          super if defined?(super)
         end
       end
     end
   end
-
-rescue Exception
 end