timber 2.6.2 → 3.0.0

data/lib/timber/overrides/active_support_tagged_logging.rb

@@ -1,66 +0,0 @@
-# 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
-
-        # @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
-
-        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
-      end
-    end
-  end
-end

data/lib/timber/overrides/lograge.rb

@@ -1,18 +0,0 @@
-# Timber and lograge are not compatible installed together. Using lograge
-# with the Timber.io *service* is perfectly fine, but not with the Timber *gem*.
-#
-# Timber does ship with a {Timber::Config#logrageify!} option that configures
-# Timber to behave similarly to Lograge (silencing various logs). Check out
-# the aforementioned method or the README for info.
-begin
-  require "lograge"
-
-  module Lograge
-    module_function
-
-    def setup(app)
-      return true
-    end
-  end
-rescue Exception
-end

data/lib/timber/overrides/rails_stdout_logging.rb

@@ -1,21 +0,0 @@
-# See https://github.com/heroku/rails_stdout_logging
-# I have no idea why this library was created, but most Heroku / Rails apps use it.
-# This library completely obliterates any logger configuration you set.
-# So this patch fixes that.
-
-begin
-  require "rails_stdout_logging"
-
-  module RailsStdoutLogging
-    class Rails2 < Rails
-      def self.set_logger
-      end
-    end
-
-    class Rails3 < Rails
-      def self.set_logger(config)
-      end
-    end
-  end
-rescue Exception
-end

data/lib/timber/util/active_support_log_subscriber.rb

@@ -1,37 +0,0 @@
-module Timber
-  module Util
-    # @private
-    module ActiveSupportLogSubscriber
-      extend self
-
-      def find(component, type)
-        ::ActiveSupport::LogSubscriber.log_subscribers.find do |subscriber|
-          subscriber.class == type
-        end
-      end
-
-      def subscribed?(component, type)
-        !find(component, type).nil?
-      end
-
-      # I don't know why this has to be so complicated, but it is. This code was taken from
-      # lograge :/
-      def unsubscribe!(component, type)
-        subscriber = find(component, type)
-
-        if !subscriber
-          raise "We could not find a log subscriber for #{component.inspect} of type #{type.inspect}"
-        end
-
-        events = subscriber.public_methods(false).reject { |method| method.to_s == 'call' }
-        events.each do |event|
-          ::ActiveSupport::Notifications.notifier.listeners_for("#{event}.#{component}").each do |listener|
-            if listener.instance_variable_get('@delegate') == subscriber
-              ::ActiveSupport::Notifications.unsubscribe listener
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/timber/util/attribute_normalizer.rb

@@ -1,89 +0,0 @@
-module Timber
-  module Util
-    # @private
-    #
-    # The purpose of this class is to normalize parameters passed to events
-    # and contexts. Timber validates a rigid JSON schema against the defined
-    # Timber log event JSON schema. This normalization process ensures the
-    # data passed to events and contexts conforms to this structure.
-    class AttributeNormalizer
-      def initialize(attributes)
-        @attributes = attributes
-      end
-
-      def fetch!(key, type, options = {})
-        v = fetch(key, type, options)
-        if v.nil?
-          raise ArgumentError.new("The #{key.inspect} attribute is required")
-        end
-        v
-      end
-
-      def fetch(key, type, options = {})
-        v = @attributes[key]
-
-        if blank?(v)
-          options[:default] || nil
-        else
-          case type
-          when :array
-            if !v.is_a?(Array)
-              raise ArgumentError.new("The #{key.inspect} attribute must be a list if provided")
-            end
-
-            v
-
-          when :float
-            v = v.to_f
-
-            if options[:precision]
-              v = v.round(options[:precision])
-            end
-
-            v
-
-          when :hash
-            if options[:sanitize]
-              v = Util::Hash.sanitize_keys(v, options[:sanitize])
-            end
-
-            v = Util::Hash.jsonify(v)
-
-            if v == {}
-              nil
-            else
-              v
-            end
-
-          when :integer
-            v.to_i
-
-          when :string
-            v = v.to_s
-
-            if options[:limit]
-              v = v.byteslice(0, options[:limit])
-            end
-
-            if options[:upcase]
-              v = v.upcase
-            end
-
-            v
-
-          when :symbol
-            v.to_sym
-
-          else
-            raise ArgumentError.new("Unknown normalization type #{type}")
-          end
-        end
-      end
-
-      private
-        def blank?(v)
-          v.nil? || (v.respond_to?(:length) && v.length == 0)
-        end
-    end
-  end
-end

data/lib/timber/util/hash.rb

@@ -1,90 +0,0 @@
-module Timber
-  module Util
-    # @private
-    module Hash
-      BINARY_LIMIT_THRESHOLD = 1_000.freeze
-      SANITIZED_VALUE = '[sanitized]'.freeze
-
-      extend self
-
-      # Deeply reduces a hash into a new hash, passing the current key, value,
-      # and accumulated map up to that point. This allows the caller to
-      # conditionally rebuild the hash.
-      def deep_reduce(hash, &block)
-        new_hash = {}
-
-        hash.each do |k, v|
-          v = if v.is_a?(::Hash)
-            deep_reduce(v, &block)
-          else
-            v
-          end
-
-          block.call(k, v, new_hash)
-        end
-
-        new_hash
-      end
-
-      # Recursively traverses a hash, dropping non-JSON compatible types.
-      # If the string is a binary, and it is > 1000 characters, it is dropped.
-      # We are assuming it represents file contents that should not be included
-      # in the logs.
-      def jsonify(hash)
-        deep_reduce(hash) do |k, v, h|
-          if v.is_a?(String)
-            if v.encoding == ::Encoding::ASCII_8BIT
-              # Only keep binary values less than a certain size. Sizes larger than this
-              # are almost always file uploads and data we do not want to log.
-              if v.length < BINARY_LIMIT_THRESHOLD
-                # Attempt to safely encode the data to UTF-8
-                encoded_value = encode_string(v)
-                if !encoded_value.nil?
-                  h[k] = encoded_value
-                end
-              end
-            elsif v.encoding != ::Encoding::UTF_8
-              h[k] = encode_string(v)
-            else
-              h[k] = v
-            end
-          elsif is_a_primitive_type?(v)
-            # Keep all other primitive types
-            h[k] = v
-          end
-        end
-      end
-
-      # Replaces matching keys with a `[Sanitized]` value.
-      def sanitize_keys(hash, keys_to_sanitize)
-        hash.each_with_object({}) do |(k, v), h|
-          k = k.to_s.downcase
-          if keys_to_sanitize.include?(k)
-            h[k] = SANITIZED_VALUE
-          else
-            h[k] = v
-          end
-        end
-      end
-
-      private
-        # Attempts to encode a non UTF-8 string into UTF-8, discarding invalid characters.
-        # If it fails, a nil is returned.
-        def encode_string(string)
-          string.encode('UTF-8', {
-            :invalid => :replace,
-            :undef   => :replace,
-            :replace => '?'
-          })
-        rescue Exception
-          nil
-        end
-
-        # We use is_a? because it accounts for inheritance.
-        def is_a_primitive_type?(v)
-          v.is_a?(Array) || v.is_a?(Integer) || v.is_a?(Float) || v.is_a?(TrueClass) ||
-            v.is_a?(FalseClass) || v.is_a?(String) || v.is_a?(Time) || v.is_a?(::Hash)
-        end
-    end
-  end
-end

data/lib/timber/util/request.rb

@@ -1,72 +0,0 @@
-begin
-  require "rack"
-rescue LoadError
-end
-
-if defined?(::Rack::Request)
-  module Timber
-    module Util
-      # @private
-      class Request < ::Rack::Request
-        # We store strings as constants since they are reused on a per request basis.
-        # This avoids string allocations.
-        HTTP_HEADER_ORIGINAL_DELIMITER = '_'.freeze
-        HTTP_HEADER_NEW_DELIMITER = '_'.freeze
-        HTTP_PREFIX = 'HTTP_'.freeze
-
-        REMOTE_IP_KEY_NAME = 'action_dispatch.remote_ip'.freeze
-        REQUEST_ID_KEY_NAME1 = 'action_dispatch.request_id'.freeze
-        REQUEST_ID_KEY_NAME2 = 'X-Request-ID'.freeze
-        REQUEST_ID_KEY_NAME3 = 'X-Request-Id'.freeze
-
-        def body_content
-          content = body.read
-          body.rewind
-          content
-        end
-
-        # Returns a list of request headers. The rack env contains a lot of data, this function
-        # identifies those that were the actual request headers.
-        #
-        # This was extracted from: https://github.com/ruby-grape/grape/blob/91c6c78ae3d3f3ffabaf57ffc4dc35ab7cfc7b5f/lib/grape/request.rb#L30
-        def headers
-          @headers ||= begin
-            headers = {}
-
-            @env.each_pair do |k, v|
-              next unless k.is_a?(String) && k.to_s.start_with?(HTTP_PREFIX)
-
-              k = k[5..-1].
-                split(HTTP_HEADER_ORIGINAL_DELIMITER).
-                each(&:capitalize!).
-                join(HTTP_HEADER_NEW_DELIMITER)
-
-              headers[k] = v
-            end
-
-            headers
-          end
-        end
-
-        def ip
-          @ip ||= if @env[REMOTE_IP_KEY_NAME]
-            @env[REMOTE_IP_KEY_NAME].to_s || super
-          else
-            super
-          end
-        end
-
-        def referer
-          # Rails 3.X returns "/" for some reason
-          @referer ||= super == "/" ? nil : super
-        end
-
-        def request_id
-          @request_id ||= @env[REQUEST_ID_KEY_NAME1] ||
-            @env[REQUEST_ID_KEY_NAME2] ||
-            @env[REQUEST_ID_KEY_NAME3]
-        end
-      end
-    end
-  end
-end

data/lib/timber/util/struct.rb

@@ -1,16 +0,0 @@
-module Timber
-  module Util
-    # @private
-    module Struct
-      extend self
-
-      def to_hash(struct)
-        h = {}
-        struct.each_pair do |k ,v|
-          h[k] = v
-        end
-        h
-      end
-    end
-  end
-end

data/spec/rails/tagged_logging_spec.rb

@@ -1,44 +0,0 @@
-require "spec_helper"
-
-# ActiveSupport::TaggedLogging is not defined in <= 3.1
-if defined?(::ActiveSupport::TaggedLogging)
-  describe ActiveSupport::TaggedLogging, :rails_23 => true do
-    describe "#new" do
-      let(:io) { StringIO.new }
-
-      it "should instantiate for Timber::Logger object" do
-        ActiveSupport::TaggedLogging.new(Timber::Logger.new(io))
-      end
-
-      if defined?(ActiveSupport::BufferedLogger)
-        it "should instantiate for a ActiveSupport::BufferedLogger object" do
-          ActiveSupport::TaggedLogging.new(ActiveSupport::BufferedLogger.new(io))
-        end
-      end
-    end
-
-    describe "#info" do
-      let(:time) { Time.utc(2016, 9, 1, 12, 0, 0) }
-      let(:io) { StringIO.new }
-      let(:logger) { ActiveSupport::TaggedLogging.new(Timber::Logger.new(io)) }
-
-      around(:each) do |example|
-        Timecop.freeze(time) { example.run }
-      end
-
-      it "should format properly with events" do
-        event = Timber::Events::SQLQuery.new(sql: "select * from users", time_ms: 56, message: "select * from users")
-        logger.tagged("tag") do
-          logger.info(event)
-        end
-        expect(io.string).to include("\"tags\":[\"tag\"]")
-      end
-
-      it "should accept events as the second argument" do
-        logger.info("SQL query", payment_rejected: {customer_id: "abcd1234", amount: 100, reason: "Card expired"})
-        expect(io.string).to start_with("SQL query @metadata")
-        expect(io.string).to include("\"event\":{\"custom\":{\"payment_rejected\":")
-      end
-    end
-  end
-end