timber 2.6.2 → 3.0.0

data/lib/timber/integrations/rack/middleware.rb

@@ -1,28 +0,0 @@
-module Timber
-  module Integrations
-    module Rack
-      # Base class that all Timber Rack middlewares extend. See the class level methods for
-      # configuration options.
-      class Middleware
-        class << self
-          # Easily enable / disable specific middlewares.
-          #
-          # @example
-          #   Timber::Integrations::Rack::UserContext.enabled = false
-          def enabled=(value)
-            @enabled = value
-          end
-
-          # Accessor method for {#enabled=}.
-          def enabled?
-            @enabled != false
-          end
-        end
-
-        def initialize(app)
-          @app = app
-        end
-      end
-    end
-  end
-end

data/lib/timber/integrations/rack/session_context.rb

@@ -1,65 +0,0 @@
-begin
-  require "rails"
-rescue Exception
-end
-
-require "timber/config"
-require "timber/contexts/session"
-require "timber/integrations/rack/middleware"
-
-module Timber
-  module Integrations
-    module Rack
-      # A Rack middleware that is responsible for adding the Session context
-      # {Timber::Contexts::Session}.
-      class SessionContext < Middleware
-        def call(env)
-          id = get_session_id(env)
-          if id
-            context = Contexts::Session.new(id: id)
-            CurrentContext.with(context) do
-              @app.call(env)
-            end
-          else
-            @app.call(env)
-          end
-        end
-
-        private
-          def get_session_id(env)
-            if defined?(::Rails)
-              session_key = ::Rails.application.config.session_options[:key]
-              request = ::ActionDispatch::Request.new(env)
-              Timber::Config.instance.debug { "Rails detected, extracting session_id from cookie" }
-              extract_from_cookie(request, session_key)
-
-            elsif session = env['rack.session']
-              if session.respond_to?(:id)
-                Timber::Config.instance.debug { "Rack env session detected, using id attribute" }
-                session.id
-              elsif session.respond_to?(:[])
-                Timber::Config.instance.debug { "Rack env session detected, using the session_id key" }
-                session["session_id"]
-              else
-                Timber::Config.instance.debug { "Rack env session detected but could not extract id" }
-                nil
-              end
-            else
-              Timber::Config.instance.debug { "No session data could be detected, skipping" }
-
-              nil
-            end
-          rescue Exception => e
-            nil
-          end
-
-          def extract_from_cookie(request, session_key)
-            data = request
-              .cookie_jar
-              .signed_or_encrypted[session_key] || {}
-            data["session_id"]
-          end
-      end
-    end
-  end
-end

data/lib/timber/integrations/rack/user_context.rb

@@ -1,135 +0,0 @@
-require "timber/config"
-require "timber/contexts/user"
-require "timber/integrations/rack/middleware"
-
-module Timber
-  module Integrations
-    module Rack
-      # This is a Rack middleware responsible for setting the user context.
-      # See {Timber::Contexts::User} for more information on the user context.
-      #
-      # ## Why a Rack middleware?
-      #
-      # We use a Rack middleware because we want to set the user context as early as
-      # possible, and before the initial incoming request log line:
-      #
-      #   Started GET /welcome
-      #
-      # The above log line is logged in a request middleware, before it reaches
-      # the controller.
-      #
-      # If, for example, we set the user context in a controller, the log line above
-      # will not have the user context attached. This is because it is logged before
-      # the controller is executed. This is not ideal, and it's why we take a middleware
-      # approach here. If for some reason you cannot identify the user at the middleware
-      # level then setting it in the controller is perfectly fine, just be aware of the
-      # above downside.
-      #
-      # ## Authentication frameworks automatically detected:
-      #
-      # If you use any of the following authentication frameworks, Timber will
-      # automatically set the user context for you.
-      #
-      # * Devise, or any Warden based authentication strategy
-      # * Clearance
-      #
-      # Or, you can use your own custom authentication, see the {.custom_user_context}
-      # class method for more details.
-      #
-      # @note This middleware is automatically inserted for frameworks we support.
-      #   Such as Rails. See {Timber::Frameworks} for a comprehensive list.
-      class UserContext < Middleware
-        class << self
-          # The custom user context allows you to hook in and set your own custom
-          # user context. This is used in situations where either:
-          #
-          # 1. Timber does not automatically support your authentication strategy (see module level docs)
-          # 2. You need to customize your authentication beyond Timber's defaults.
-          #
-          # @example Setting your own custom user context
-          #   Timber::Integrations::Rack::UserContext.custom_user_hash = lambda do |rack_env|
-          #     rack_env['my_custom_key'].user
-          #   end
-          def custom_user_hash=(proc)
-            if proc && !proc.is_a?(Proc)
-              raise ArgumentError.new("The value passed to #custom_user_hash must be a Proc")
-            end
-
-            @custom_user_hash = proc
-          end
-
-          # Accessor method for {#custom_user_hash=}.
-          def custom_user_hash
-            @custom_user_hash
-          end
-        end
-
-        def call(env)
-          user_hash = get_user_hash(env)
-          if user_hash
-            context = Contexts::User.new(user_hash)
-            CurrentContext.with(context) do
-              @app.call(env)
-            end
-          else
-            @app.call(env)
-          end
-        end
-
-        private
-          def get_user_hash(env)
-            # The order is relevant here. The 'warden' key can be set, but
-            # not return a user, in which case the user data might be in another key.
-            if self.class.custom_user_hash.is_a?(Proc)
-              Timber::Config.instance.debug { "Obtaining user context from the custom user hash" }
-              self.class.custom_user_hash.call(env)
-            elsif env[:clearance] && env[:clearance].signed_in?
-              Timber::Config.instance.debug { "Obtaining user context from the clearance user" }
-              user = env[:clearance].current_user
-              get_user_object_hash(user)
-            elsif env['warden'] && (user = env['warden'].user)
-              Timber::Config.instance.debug { "Obtaining user context from the warden user" }
-              get_user_object_hash(user)
-            else
-              Timber::Config.instance.debug { "Could not locate any user data" }
-              nil
-            end
-          end
-
-          def get_user_object_hash(user)
-            id = try_user_id(user)
-            name = try_user_name(user)
-            email = try_user_email(user)
-
-            if id || name || email
-              {id: id, name: name, email: email}
-            else
-              nil
-            end
-          end
-
-          def try_user_id(user)
-            user.respond_to?(:id) ? user.id : nil
-          end
-
-          def try_user_name(user)
-            if user.respond_to?(:name) && user.name.is_a?(String)
-              user.name
-            elsif user.respond_to?(:first_name) && user.first_name.is_a?(String) && user.respond_to?(:last_name) && user.last_name.is_a?(String)
-              "#{user.first_name} #{user.last_name}"
-            else
-              nil
-            end
-          end
-
-          def try_user_email(user)
-            if user.respond_to?(:email) && user.email.is_a?(String)
-              user.email
-            else
-              nil
-            end
-          end
-      end
-    end
-  end
-end

data/lib/timber/integrations/rails.rb

@@ -1,22 +0,0 @@
-require "timber/integration"
-require "timber/integrations/rack/http_events"
-require "timber/integrations/rails/rack_logger"
-
-module Timber
-  module Integrations
-    # Module for holding *all* Rails integrations. This module does *not*
-    # extend {Integration} because it's dependent on {Rack::HTTPEvents}. This
-    # module simply disables the default HTTP request logging.
-    module Rails
-      def self.enabled?
-        Rack::HTTPEvents.enabled?
-      end
-
-      def self.integrate!
-        return false if !enabled?
-
-        RackLogger.integrate!
-      end
-    end
-  end
-end

data/lib/timber/integrations/rails/rack_logger.rb

@@ -1,60 +0,0 @@
-require "timber/integrator"
-
-module Timber
-  module Integrations
-    module Rails
-      # Disables the default rail's rack logging. Note, we cannot simply uninstall this rack
-      # middleware because rails couples this with ActiveSupport instrumentation. As such,
-      # we simply disable the logger and let our Rack middleware handle the logging.
-      #
-      # See: https://github.com/rails/rails/blob/80e66cc4d90bf8c15d1a5f6e3152e90147f00772/railties/lib/rails/rack/logger.rb#L34
-      #
-      # @private
-      class RackLogger < Integrator
-
-        # @private
-        module InstanceMethods
-          LOGGER = ::Logger.new(nil)
-
-          def self.included(klass)
-            klass.class_eval do
-              private
-                if ::Rails::VERSION::MAJOR == 3
-                  # Rails 3.2 calls Rails.logger directly in call_app, so we
-                  # will just replace it with a version that doesn't
-                  def call_app(_, env)
-                    # Put some space between requests in development logs.
-                    if ::Rails.env.development?
-                      ::Rails.logger.info ''
-                      ::Rails.logger.info ''
-                    end
-                    @app.call(env)
-                  ensure
-                    ActiveSupport::LogSubscriber.flush_all!
-                  end
-                end
-
-                # Rails > 3.2 uses a logger method. Muting logs is accomplished by
-                # passing a dummy logger instance with a nil log device.
-                def logger
-                  LOGGER
-                end
-            end
-          end
-        end
-
-        def initialize
-          require "rails/rack/logger"
-        rescue LoadError => e
-          raise RequirementNotMetError.new(e.message)
-        end
-
-        def integrate!
-          return true if ::Rails::Rack::Logger.include?(InstanceMethods)
-
-          ::Rails::Rack::Logger.send(:include, InstanceMethods)
-        end
-      end
-    end
-  end
-end

data/lib/timber/overrides.rb

@@ -1,12 +0,0 @@
-# The order is relevant
-require "timber/overrides/active_support_3_tagged_logging"
-require "timber/overrides/active_support_tagged_logging"
-require "timber/overrides/active_support_buffered_logger"
-require "timber/overrides/lograge"
-require "timber/overrides/rails_stdout_logging"
-
-module Timber
-  # @private
-  module Overrides
-  end
-end

data/lib/timber/overrides/active_support_3_tagged_logging.rb

@@ -1,111 +0,0 @@
-# Please note, this patch is merely an upgrade, backporting improved tagged logging code
-# from newer versions of Rails:
-# https://github.com/rails/rails/blob/5-1-stable/activesupport/lib/active_support/tagged_logging.rb
-# The behavior of tagged logging will not change in any way.
-#
-# 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)
-          if logger.respond_to?(:formatter=) && logger.respond_to?(:formatter)
-            # Ensure we set a default formatter so we aren't extending nil!
-            logger.formatter ||= SimpleFormatter.new
-            logger.formatter.extend Formatter
-          end
-
-          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_buffered_logger.rb

@@ -1,22 +0,0 @@
-# This adds a #formatter and #formatter= method to the legacy ActiveSupport::BufferedLogger
-# class. This bug was never resolved due to it being phased out past Rails >= 4.
-
-begin
-  require "active_support/buffered_logger"
-
-  class ActiveSupport::BufferedLogger
-    def formatter
-      if @log.respond_to?(:formatter)
-        @log.formatter
-      end
-    end
-
-    def formatter=(value)
-      if @log.respond_to?(:formatter=)
-        @log.formatter = value
-      end
-    end
-  end
-
-rescue Exception
-end