timber-rails 1.0.0

data/lib/timber-rails/config/action_controller.rb

@@ -0,0 +1,29 @@
+require "timber-rails/action_controller"
+
+module Timber
+  class Config
+    # Convenience module for accessing the various `Timber::Integrations::*` classes
+    # through the {Timber::Config} object. Timber couples configuration with the class
+    # responsible for implementing it. This provides for a tighter design, but also
+    # requires the user to understand and access the various classes. This module aims
+    # to provide a simple ruby-like configuration interface for internal Timber classes.
+    #
+    # For example:
+    #
+    #     config = Timber::Config.instance
+    #     config.integrations.active_record.silence = true
+    module Integrations
+      extend self
+
+      # Convenience method for accessing the {Timber::Integrations::ActionController} class
+      # specific configuration.
+      #
+      # @example
+      #   config = Timber::Config.instance
+      #   config.integrations.action_controller.silence = true
+      def action_controller
+        Timber::Integrations::ActionController
+      end
+    end
+  end
+end

data/lib/timber-rails/config/action_view.rb

@@ -0,0 +1,29 @@
+require "timber-rails/action_view"
+
+module Timber
+  class Config
+    # Convenience module for accessing the various `Timber::Integrations::*` classes
+    # through the {Timber::Config} object. Timber couples configuration with the class
+    # responsible for implementing it. This provides for a tighter design, but also
+    # requires the user to understand and access the various classes. This module aims
+    # to provide a simple ruby-like configuration interface for internal Timber classes.
+    #
+    # For example:
+    #
+    #     config = Timber::Config.instance
+    #     config.integrations.active_record.silence = true
+    module Integrations
+      extend self
+
+      # Convenience method for accessing the {Timber::Integrations::ActionView} class
+      # specific configuration.
+      #
+      # @example
+      #   config = Timber::Config.instance
+      #   config.integrations.action_view.silence = true
+      def action_view
+        Timber::Integrations::ActionView
+      end
+    end
+  end
+end

data/lib/timber-rails/config/active_record.rb

@@ -0,0 +1,29 @@
+require "timber-rails/active_record"
+
+module Timber
+  class Config
+    # Convenience module for accessing the various `Timber::Integrations::*` classes
+    # through the {Timber::Config} object. Timber couples configuration with the class
+    # responsible for implementing it. This provides for a tighter design, but also
+    # requires the user to understand and access the various classes. This module aims
+    # to provide a simple ruby-like configuration interface for internal Timber classes.
+    #
+    # For example:
+    #
+    #     config = Timber::Config.instance
+    #     config.integrations.active_record.silence = true
+    module Integrations
+      extend self
+
+      # Convenience method for accessing the {Timber::Integrations::ActiveRecord} class
+      # specific configuration.
+      #
+      # @example
+      #   config = Timber::Config.instance
+      #   config.integrations.active_record.silence = true
+      def active_record
+        Timber::Integrations::ActiveRecord
+      end
+    end
+  end
+end

data/lib/timber-rails/config.rb

@@ -0,0 +1,12 @@
+require 'timber/config'
+require 'timber-rack/config'
+require 'timber-rails/config/action_view'
+require 'timber-rails/config/active_record'
+require 'timber-rails/config/action_controller'
+
+Timber::Config.instance.define_singleton_method(:logrageify!) do
+  integrations.action_controller.silence = true
+  integrations.action_view.silence = true
+  integrations.active_record.silence = true
+  integrations.rack.http_events.collapse_into_single_event = true
+end

data/lib/timber-rails/error_event.rb

@@ -0,0 +1,61 @@
+begin
+  # Rails 3.2 requires you to require all of Rails before requiring
+  # the exception wrapper.
+  require "action_dispatch/middleware/exception_wrapper"
+rescue Exception
+end
+
+require "timber/events/error"
+require "timber-rack/middleware"
+require "timber/util"
+
+module Timber
+  module Integrations
+    module Rails
+      # A Rack middleware that is reponsible for capturing exception and error events
+      # {Timber::Events::Error}.
+      class ErrorEvent < Timber::Integrations::Rack::Middleware
+        # We determine this when the app loads to avoid the overhead on a per request basis.
+        EXCEPTION_WRAPPER_TAKES_CLEANER = defined?(::ActionDispatch::ExceptionWrapper) &&
+          !::ActionDispatch::ExceptionWrapper.instance_methods.include?(:env)
+
+        def call(env)
+          begin
+            status, headers, body = @app.call(env)
+          rescue Exception => exception
+            Config.instance.logger.fatal do
+              backtrace = extract_backtrace(env, exception)
+              Events::Error.new(
+                name: exception.class.name,
+                error_message: exception.message,
+                backtrace: backtrace
+              )
+            end
+
+            raise exception
+          end
+        end
+
+        private
+          # Rails provides a backtrace cleaner, so we use it here.
+          def extract_backtrace(env, exception)
+            if defined?(::ActionDispatch::ExceptionWrapper)
+              wrapper = if EXCEPTION_WRAPPER_TAKES_CLEANER
+                request = Util::Request.new(env)
+                backtrace_cleaner = request.get_header("action_dispatch.backtrace_cleaner")
+                ::ActionDispatch::ExceptionWrapper.new(backtrace_cleaner, exception)
+              else
+                ::ActionDispatch::ExceptionWrapper.new(env, exception)
+              end
+
+              trace = wrapper.application_trace
+              trace = wrapper.framework_trace if trace.empty?
+              trace
+            else
+              exception.backtrace
+            end
+          end
+      end
+    end
+  end
+end

data/lib/timber-rails/logger.rb

@@ -0,0 +1,15 @@
+module Timber
+  # The Timber Logger behaves exactly like the standard Ruby `::Logger`, except that it supports a
+  # transparent API for logging structured data and events.
+  #
+  # @example Basic logging
+  #   logger.info "Payment rejected for customer #{customer_id}"
+  #
+  # @example Logging an event
+  #   logger.info "Payment rejected", payment_rejected: {customer_id: customer_id, amount: 100}
+  class Logger < ::Logger
+    include ::ActiveSupport::LoggerThreadSafeLevel if defined?(::ActiveSupport::LoggerThreadSafeLevel)
+    include ::LoggerSilence if defined?(::LoggerSilence)
+  end
+end
+

data/lib/timber-rails/overrides/active_support_3_tagged_logging.rb

@@ -0,0 +1,111 @@
+# 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-rails/overrides/active_support_buffered_logger.rb

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

data/lib/timber-rails/overrides/active_support_tagged_logging.rb

@@ -0,0 +1,66 @@
+# 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-rails/overrides/lograge.rb

@@ -0,0 +1,18 @@
+# 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-rails/overrides/rails_stdout_logging.rb

@@ -0,0 +1,21 @@
+# 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-rails/overrides.rb

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

data/lib/timber-rails/rack_logger.rb

@@ -0,0 +1,58 @@
+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-rails/railtie.rb

@@ -0,0 +1,27 @@
+module Timber
+  module Frameworks
+    # Module for Rails specific code, such as the Railtie and any methods that assist
+    # with Rails setup.
+    module Rails
+      # Installs Timber into your Rails app automatically.
+      class Railtie < ::Rails::Railtie
+        config.timber = Config.instance
+
+        config.before_initialize do
+          Timber::Config.instance.logger = Proc.new { ::Rails.logger }
+        end
+
+        # Must be loaded after initializers so that we respect any Timber configuration set
+        initializer(:timber, before: :build_middleware_stack, after: :load_config_initializers) do
+          Integrations::Rails.integrate!
+
+          # Install the Rack middlewares so that we capture structured data instead of
+          # raw text logs.
+          Integrations::Rails.middlewares.collect do |middleware_class|
+            config.app_middleware.use middleware_class
+          end
+        end
+      end
+    end
+  end
+end

data/lib/timber-rails/session_context.rb

@@ -0,0 +1,40 @@
+require "timber/contexts/session"
+require "timber-rack/middleware"
+
+module Timber
+  module Integrations
+    module Rails
+      # A Rack middleware that is responsible for adding the Session context
+      # {Timber::Contexts::Session}.
+      class SessionContext < Timber::Integrations::Rack::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)
+            session_key = ::Rails.application.config.session_options[:key]
+            request = ::ActionDispatch::Request.new(env)
+            extract_from_cookie(request, session_key)
+          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-rails/version.rb

@@ -0,0 +1,7 @@
+module Timber
+  module Integrations
+    module Rails
+      VERSION = "1.0.0"
+    end
+  end
+end

data/lib/timber-rails.rb

@@ -0,0 +1,63 @@
+require "timber-rails/overrides"
+
+require "timber"
+require "rails"
+require "timber-rails/config"
+require "timber-rails/railtie"
+
+require "timber-rack/http_context"
+require "timber-rack/http_events"
+require "timber-rack/user_context"
+require "timber-rails/session_context"
+require "timber-rails/rack_logger"
+require "timber-rails/error_event"
+
+require "timber-rails/action_controller"
+require "timber-rails/action_dispatch"
+require "timber-rails/action_view"
+require "timber-rails/active_record"
+
+require "timber-rails/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?
+        Timber::Integrations::Rack::HTTPEvents.enabled?
+      end
+
+      def self.integrate!
+        return false if !enabled?
+
+        ActionController.integrate!
+        ActionDispatch.integrate!
+        ActionView.integrate!
+        ActiveRecord.integrate!
+        RackLogger.integrate!
+      end
+
+      def self.enabled=(value)
+        Timber::Integrations::Rails::ErrorEvent.enabled = value
+        Timber::Integrations::Rack::HTTPContext.enabled = value
+        Timber::Integrations::Rack::HTTPEvents.enabled = value
+        Timber::Integrations::Rack::UserContext.enabled = value
+        SessionContext.enabled = value
+
+        ActionController.enabled = value
+        ActionView.enabled = value
+        ActiveRecord.enabled = value
+      end
+
+      # All enabled middlewares. The order is relevant. Middlewares that set
+      # context are added first so that context is included in subsequent log lines.
+      def self.middlewares
+        @middlewares ||= [Timber::Integrations::Rack::HTTPContext, SessionContext, Timber::Integrations::Rack::UserContext,
+          Timber::Integrations::Rack::HTTPEvents, Timber::Integrations::Rails::ErrorEvent].select(&:enabled?)
+      end
+    end
+  end
+end
+