timber 1.1.14 → 2.0.0

data/lib/timber/probe.rb

@@ -1,23 +0,0 @@
-module Timber
-  # Base class for `Timber::Probes::*`.
-  # @private
-  class Probe
-    class RequirementNotMetError < StandardError; end
-
-    class << self
-      def insert!(*args)
-        new(*args).insert!
-        Config.instance.logger.debug("Inserted probe #{name}")
-        true
-      # RequirementUnsatisfiedError is the only silent failure we support
-      rescue RequirementNotMetError => e
-        Config.instance.logger.debug("Failed inserting probe #{name}: #{e.message}")
-        false
-      end
-    end
-
-    def insert!
-      raise NotImplementedError.new
-    end
-  end
-end

data/lib/timber/probes.rb

@@ -1,23 +0,0 @@
-require "timber/probes/action_controller_log_subscriber"
-require "timber/probes/action_controller_user_context"
-require "timber/probes/action_dispatch_debug_exceptions"
-require "timber/probes/action_view_log_subscriber"
-require "timber/probes/active_record_log_subscriber"
-require "timber/probes/active_support_tagged_logging"
-require "timber/probes/rails_rack_logger"
-
-module Timber
-  # Namespace for all probes.
-  # @private
-  module Probes
-    def self.insert!
-      ActionControllerLogSubscriber.insert!
-      ActionControllerUserContext.insert!
-      ActionDispatchDebugExceptions.insert!
-      ActionViewLogSubscriber.insert!
-      ActiveRecordLogSubscriber.insert!
-      ActiveSupportTaggedLogging.insert!
-      RailsRackLogger.insert!
-    end
-  end
-end

data/lib/timber/probes/action_controller_log_subscriber.rb

@@ -1,20 +0,0 @@
-module Timber
-  module Probes
-    # Responsible for automatically tracking controller call and http response events
-    # for applications that use `ActionController`.
-    class ActionControllerLogSubscriber < Probe
-      def initialize
-        require "action_controller/log_subscriber"
-        require "timber/probes/action_controller_log_subscriber/log_subscriber"
-      rescue LoadError => e
-        raise RequirementNotMetError.new(e.message)
-      end
-
-      def insert!
-        return true if Util::ActiveSupportLogSubscriber.subscribed?(:action_controller, LogSubscriber)
-        Util::ActiveSupportLogSubscriber.unsubscribe(:action_controller, ::ActionController::LogSubscriber)
-        LogSubscriber.attach_to(:action_controller)
-      end
-    end
-  end
-end

data/lib/timber/probes/action_controller_log_subscriber/log_subscriber.rb

@@ -1,64 +0,0 @@
-module Timber
-  module Probes
-    class ActionControllerLogSubscriber < Probe
-      # The log subscriber that replaces the default `ActionController::LogSubscriber`.
-      # The intent of this subscriber is to, as transparently as possible, properly
-      # track events that are being logged here. This LogSubscriber will never change
-      # default behavior / log messages.
-      class LogSubscriber < ::ActionController::LogSubscriber
-        def start_processing(event)
-          info do
-            payload = event.payload
-            params  = payload[:params].except(*INTERNAL_PARAMS)
-            format  = extract_format(payload)
-            format  = format.to_s.upcase if format.is_a?(Symbol)
-
-            Events::ControllerCall.new(
-              controller: payload[:controller],
-              action: payload[:action],
-              format: format,
-              params: params
-            )
-          end
-        end
-
-        def process_action(event)
-          info do
-            payload   = event.payload
-            additions = ActionController::Base.log_process_action(payload)
-
-            status = payload[:status]
-            if status.nil? && payload[:exception].present?
-              exception_class_name = payload[:exception].first
-              status = extract_status(exception_class_name)
-            end
-
-            Events::HTTPServerResponse.new(
-              status: status,
-              time_ms: event.duration,
-              additions: additions
-            )
-          end
-        end
-
-        private
-          def extract_format(payload)
-            if payload.key?(:format)
-              payload[:format] # rails > 4.X
-            elsif payload.key?(:formats)
-              payload[:formats].first # rails 3.X
-            end
-          end
-
-          def extract_status(exception_class_name)
-            if defined?(ActionDispatch::ExceptionWrapper)
-              ActionDispatch::ExceptionWrapper.status_code_for_exception(exception_class_name)
-            else
-              # Rails 3.X
-              Rack::Utils.status_code(ActionDispatch::ShowExceptions.rescue_responses[exception_class_name]) rescue nil
-            end
-          end
-      end
-    end
-  end
-end

data/lib/timber/probes/action_controller_user_context.rb

@@ -1,52 +0,0 @@
-module Timber
-  module Probes
-    # Responsible for automatically tracking controller call and http response events
-    # for applications that use `ActionController`.
-    class ActionControllerUserContext < Probe
-      module AroundFilter
-        def self.included(klass)
-          klass.class_eval do
-            if klass.respond_to?(:around_action)
-              around_action :_timber_capture_user_context
-            else
-              around_filter :_timber_capture_user_context
-            end
-
-            private
-              def _timber_capture_user_context
-                if respond_to?(:current_user, true)
-                  id = Timber::Util::Object.try(current_user, :id)
-                  name = Timber::Util::Object.try(current_user, :name)
-                  if !name
-                    first_name = Timber::Util::Object.try(current_user, :first_name)
-                    last_name = Timber::Util::Object.try(current_user, :last_name)
-                    if first_name || last_name
-                      name = [first_name, last_name].compact.join(" ")
-                    end
-                  end
-                  email = Timber::Util::Object.try(current_user, :email)
-                  user_context = Timber::Contexts::User.new(:id => id, :name => name, :email => email)
-                  Timber::CurrentContext.with(user_context) do
-                    yield
-                  end
-                else
-                  yield
-                end
-              end
-          end
-        end
-      end
-
-      def initialize
-        require "action_controller"
-      rescue LoadError => e
-        raise RequirementNotMetError.new(e.message)
-      end
-
-      def insert!
-        return true if ActionController::Base.include?(AroundFilter)
-        ActionController::Base.send(:include, AroundFilter)
-      end
-    end
-  end
-end

data/lib/timber/probes/action_dispatch_debug_exceptions.rb

@@ -1,80 +0,0 @@
-module Timber
-  module Probes
-    # Reponsible for automatically tracking exception events in Rails applications. While
-    # still preserving the default log style.
-    class ActionDispatchDebugExceptions < Probe
-      # For Rails >= 3.1
-      # @private
-      module DebugExceptionsInstanceMethods
-        def self.included(klass)
-          klass.class_eval do
-            private
-              def log_error(request, wrapper)
-                logger = logger(request)
-                return unless logger
-
-                exception = wrapper.exception
-
-                trace = wrapper.application_trace
-                trace = wrapper.framework_trace if trace.empty?
-
-                event = Events::Exception.new(
-                  name: exception.class.name,
-                  exception_message: exception.message,
-                  backtrace: trace
-                )
-
-                logger.fatal event
-              end
-          end
-        end
-      end
-
-      # For Rails < 3.1
-      # @private
-      module ShowExceptionsInstanceMethods #:nodoc:
-        def self.included(klass)
-          klass.class_eval do
-            private
-              # We have to monkey patch because ruby < 2.0 does not support prepend.
-              alias_method :_timber_old_log_error, :log_error
-
-              def log_error(exception)
-                return unless logger
-
-                event = Events::Exception.new(
-                  name: exception.class.name,
-                  exception_message: exception.message,
-                  backtrace: application_trace(exception)
-                )
-
-                logger.fatal event
-              end
-          end
-        end
-      end
-
-      def initialize
-        begin
-          # Rails >= 3.1
-          require "action_dispatch/middleware/debug_exceptions"
-        rescue LoadError
-          # Rails < 3.1
-          require "action_dispatch/middleware/show_exceptions"
-        end
-      rescue LoadError => e
-        raise RequirementNotMetError.new(e.message)
-      end
-
-      def insert!
-        if defined?(::ActionDispatch::DebugExceptions)
-          return true if ::ActionDispatch::DebugExceptions.include?(DebugExceptionsInstanceMethods)
-          ::ActionDispatch::DebugExceptions.send(:include, DebugExceptionsInstanceMethods)
-        else
-          return true if ::ActionDispatch::ShowExceptions.include?(ShowExceptionsInstanceMethods)
-          ::ActionDispatch::ShowExceptions.send(:include, ShowExceptionsInstanceMethods)
-        end
-      end
-    end
-  end
-end

data/lib/timber/probes/action_view_log_subscriber.rb

@@ -1,20 +0,0 @@
-module Timber
-  module Probes
-    # Reponsible for automatically tracking template rendering events in `ActionView` while
-    # still preserving the default log style.
-    class ActionViewLogSubscriber < Probe
-      def initialize
-        require "action_view/log_subscriber"
-        require "timber/probes/action_view_log_subscriber/log_subscriber"
-      rescue LoadError => e
-        raise RequirementNotMetError.new(e.message)
-      end
-
-      def insert!
-        return true if Util::ActiveSupportLogSubscriber.subscribed?(:action_view, LogSubscriber)
-        Util::ActiveSupportLogSubscriber.unsubscribe(:action_view, ::ActionView::LogSubscriber)
-        LogSubscriber.attach_to(:action_view)
-      end
-    end
-  end
-end

data/lib/timber/probes/action_view_log_subscriber/log_subscriber.rb

@@ -1,69 +0,0 @@
-  module Timber
-  module Probes
-    class ActionViewLogSubscriber < Probe
-      # The log subscriber that replaces the default `ActionView::LogSubscriber`.
-      # The intent of this subscriber is to, as transparently as possible, properly
-      # track events that are being logged here. This LogSubscriber will never change
-      # default behavior / log messages.
-      class LogSubscriber < ::ActionView::LogSubscriber
-        def render_template(event)
-          info do
-            full_name = from_rails_root(event.payload[:identifier])
-            message = "  Rendered #{full_name}"
-            message << " within #{from_rails_root(event.payload[:layout])}" if event.payload[:layout]
-            message << " (#{event.duration.round(1)}ms)"
-
-            Events::TemplateRender.new(
-              name: full_name,
-              time_ms: event.duration,
-              message: message
-            )
-          end
-        end
-
-        def render_partial(event)
-          info do
-            full_name = from_rails_root(event.payload[:identifier])
-            message = "  Rendered #{full_name}"
-            message << " within #{from_rails_root(event.payload[:layout])}" if event.payload[:layout]
-            message << " (#{event.duration.round(1)}ms)"
-            message << " #{cache_message(event.payload)}" if event.payload.key?(:cache_hit)
-
-            Events::TemplateRender.new(
-              name: full_name,
-              time_ms: event.duration,
-              message: message
-            )
-          end
-        end
-
-        def render_collection(event)
-          if respond_to?(:render_count, true)
-            info do
-              identifier = event.payload[:identifier] || "templates"
-              full_name = from_rails_root(identifier)
-              message = "  Rendered collection of #{full_name}" \
-                " #{render_count(event.payload)} (#{event.duration.round(1)}ms)"
-
-              Events::TemplateRender.new(
-                name: full_name,
-                time_ms: event.duration,
-                message: message
-              )
-            end
-          else
-            # Older versions of rails delegate this method to #render_template
-            render_template(event)
-          end
-        end
-
-        private
-          def log_rendering_start(payload)
-            # Consolidates 2 template rendering events into 1. We don't need 2 events for
-            # rendering a template. If you disagree, please feel free to open a PR and we
-            # can make this an option.
-          end
-      end
-    end
-  end
-end

data/lib/timber/probes/active_record_log_subscriber.rb

@@ -1,20 +0,0 @@
-module Timber
-  module Probes
-    # Reponsible for automatimcally tracking SQL query events in `ActiveRecord`, while still
-    # preserving the default log style.
-    class ActiveRecordLogSubscriber < Probe
-      def initialize
-        require "active_record/log_subscriber"
-        require "timber/probes/active_record_log_subscriber/log_subscriber"
-      rescue LoadError => e
-        raise RequirementNotMetError.new(e.message)
-      end
-
-      def insert!
-        return true if Util::ActiveSupportLogSubscriber.subscribed?(:active_record, LogSubscriber)
-        Util::ActiveSupportLogSubscriber.unsubscribe(:active_record, ::ActiveRecord::LogSubscriber)
-        LogSubscriber.attach_to(:active_record)
-      end
-    end
-  end
-end

data/lib/timber/probes/active_record_log_subscriber/log_subscriber.rb

@@ -1,31 +0,0 @@
-module Timber
-  module Probes
-    class ActiveRecordLogSubscriber < Probe
-      # The log subscriber that replaces the default `ActiveRecord::LogSubscriber`.
-      # The intent of this subscriber is to, as transparently as possible, properly
-      # track events that are being logged here. This LogSubscriber will never change
-      # default behavior / log messages.
-      class LogSubscriber < ::ActiveRecord::LogSubscriber #:nodoc:
-        def sql(event)
-          super(event)
-
-          if @message
-            payload = event.payload
-            event = Events::SQLQuery.new(
-              sql: payload[:sql],
-              time_ms: event.duration,
-              message: @message
-            )
-
-            logger.debug event
-          end
-        end
-
-        private
-          def debug(message)
-            @message = message
-          end
-      end
-    end
-  end
-end

data/lib/timber/probes/active_support_tagged_logging.rb

@@ -1,63 +0,0 @@
-module Timber
-  module Probes
-    # Reponsible for automatimcally tracking SQL query events in `ActiveRecord`, while still
-    # preserving the default log style.
-    class ActiveSupportTaggedLogging < Probe
-      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
-
-      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
-
-      def initialize
-        require "active_support/tagged_logging"
-      rescue LoadError => e
-        raise RequirementNotMetError.new(e.message)
-      end
-
-      def insert!
-        if defined?(ActiveSupport::TaggedLogging::Formatter)
-          return true if ActiveSupport::TaggedLogging::Formatter.include?(FormatterMethods)
-          ActiveSupport::TaggedLogging::Formatter.send(:include, FormatterMethods)
-        else
-          return true if ActiveSupport::TaggedLogging.include?(LoggerMethods)
-          ActiveSupport::TaggedLogging.send(:include, LoggerMethods)
-        end
-      end
-    end
-  end
-end