timber 1.1.14 → 2.0.0

data/lib/timber/events/http_client_response.rb

@@ -0,0 +1,47 @@
+module Timber
+  module Events
+    # The HTTP client response event tracks responses for *outgoing* HTTP *requests*.
+    # This gives you structured insight into communication with external services.
+    #
+    # @note This event should be installed automatically through integrations,
+    #   such as the {Integrations::NetHTTP} integration.
+    class HTTPClientResponse < Timber::Event
+      attr_reader :body, :headers, :request_id, :service_name, :status, :time_ms
+
+      def initialize(attributes)
+        @headers = Util::HTTPEvent.normalize_headers(attributes[:headers])
+        @request_id = attributes[:request_id]
+        @service_name = attributes[:service_name]
+        @status = attributes[:status] || raise(ArgumentError.new(":status is required"))
+        @time_ms = attributes[:time_ms] || raise(ArgumentError.new(":time_ms is required"))
+        @time_ms = @time_ms.round(6)
+
+        @body = Util::HTTPEvent.normalize_body(@headers["content-type"], attributes[:body])
+      end
+
+      def to_hash
+        {body: body, headers: headers, request_id: request_id, service_name: service_name,
+          status: status, time_ms: time_ms}
+      end
+      alias to_h to_hash
+
+      def as_json(_options = {})
+        {:server_side_app => {:http_client_response => to_hash}}
+      end
+
+      def message
+        message = "Outgoing HTTP response"
+
+        if service_name
+          message << " from #{service_name}"
+        end
+
+        message << " #{status_description} in #{time_ms}ms"
+      end
+
+      def status_description
+        Rack::Utils::HTTP_STATUS_CODES[status]
+      end
+    end
+  end
+end

data/lib/timber/events/http_server_request.rb

@@ -1,31 +1,30 @@
 module Timber
   module Events
-    # The HTTP request event tracks incoming HTTP requests.
+    # The HTTP server request event tracks incoming HTTP requests to your HTTP server.
+    # Such as unicorn, webrick, puma, etc.
     #
-    # @note This event should be installed automatically through probes,
-    #   such as the {Probes::ActionControllerLogSubscriber} probe.
+    # @note This event should be installed automatically through integrations,
+    #   such as the {Integrations::ActionController::LogSubscriber} integration.
     class HTTPServerRequest < Timber::Event
-      attr_reader :host, :method, :path, :port, :query_string, :content_type,
-        :remote_addr, :referrer, :request_id, :scheme, :user_agent
+      attr_reader :body, :headers, :host, :method, :path, :port, :query_string, :request_id,
+        :scheme
 
       def initialize(attributes)
+        @headers = Util::HTTPEvent.normalize_headers(attributes[:headers])
         @host = attributes[:host] || raise(ArgumentError.new(":host is required"))
-        @method = attributes[:method] || raise(ArgumentError.new(":method is required"))
+        @method = Util::HTTPEvent.normalize_method(attributes[:method]) || raise(ArgumentError.new(":method is required"))
         @path = attributes[:path] || raise(ArgumentError.new(":path is required"))
         @port = attributes[:port]
-        @query_string = attributes[:query_string]
-        @content_type = attributes[:content_type]
-        @remote_addr = attributes[:remote_addr]
-        @referrer = attributes[:referrer]
-        @request_id = attributes[:request_id]
+        @query_string = Util::HTTPEvent.normalize_query_string(attributes[:query_string])
         @scheme = attributes[:scheme] || raise(ArgumentError.new(":scheme is required"))
-        @user_agent = attributes[:user_agent]
+        @request_id = attributes[:request_id]
+
+        @body = Util::HTTPEvent.normalize_body(@headers["content-type"], attributes[:body])
       end
 
       def to_hash
-        {host: host, method: method, path: path, port: port, query_string: query_string,
-          headers: {content_type: content_type, remote_addr: remote_addr, referrer: referrer,
-            request_id: request_id, scheme: scheme, user_agent: user_agent}}
+        {body: body, headers: headers, host: host, method: method, path: path, port: port,
+          query_string: query_string, request_id: request_id, scheme: scheme}
       end
       alias to_h to_hash
 
@@ -34,14 +33,7 @@ module Timber
       end
 
       def message
-        'Started %s "%s" for %s' % [
-        method,
-        path,
-        remote_addr]
-      end
-
-      def status_description
-        Rack::Utils::HTTP_STATUS_CODES[status]
+        'Started %s "%s"' % [method, path]
       end
     end
   end

data/lib/timber/events/http_server_response.rb

@@ -1,21 +1,23 @@
 module Timber
   module Events
-    # The HTTP response event tracks outgoing HTTP request responses.
+    # The HTTP server response event tracks outgoing HTTP responses that you send
+    # to clients.
     #
-    # @note This event should be installed automatically through probes,
-    #   such as the {Probes::ActionControllerLogSubscriber} probe.
+    # @note This event should be installed automatically through integrations,
+    #   such as the {Integrations::ActionController::LogSubscriber} integration.
     class HTTPServerResponse < Timber::Event
-      attr_reader :status, :time_ms, :additions
+      attr_reader :headers, :request_id, :status, :time_ms
 
       def initialize(attributes)
+        @headers = Util::HTTPEvent.normalize_headers(attributes[:headers])
+        @request_id = attributes[:request_id]
         @status = attributes[:status] || raise(ArgumentError.new(":status is required"))
         @time_ms = attributes[:time_ms] || raise(ArgumentError.new(":time_ms is required"))
         @time_ms = @time_ms.round(6)
-        @additions = attributes[:additions]
       end
 
       def to_hash
-        {status: status, time_ms: time_ms}
+        {headers: headers, request_id: request_id, status: status, time_ms: time_ms}
       end
       alias to_h to_hash
 
@@ -24,9 +26,7 @@ module Timber
       end
 
       def message
-        message = "Completed #{status} #{status_description} in #{time_ms}ms"
-        message << " (#{additions.join(" | ".freeze)})" unless additions.empty?
-        message
+        "Completed #{status} #{status_description} in #{time_ms}ms"
       end
 
       def status_description

data/lib/timber/events/sql_query.rb

@@ -2,8 +2,8 @@ module Timber
   module Events
     # The SQL query event tracks sql queries to your database.
     #
-    # @note This event should be installed automatically through probes,
-    #   such as the {Probes::ActiveRecordLogSubscriber} probe.
+    # @note This event should be installed automatically through integrations,
+    #   such as the {Integrations::ActiveRecord::LogSubscriber} integration.
     class SQLQuery < Timber::Event
       attr_reader :sql, :time_ms, :message
 

data/lib/timber/events/template_render.rb

@@ -2,8 +2,8 @@ module Timber
   module Events
     # The template render event track template renderings and their performance.
     #
-    # @note This event should be installed automatically through probes,
-    #   such as the {Probes::ActionViewLogSubscriber} probe.
+    # @note This event should be installed automatically through integrations,
+    #   such as the {Integrations::ActionView::LogSubscriber} integration.
     class TemplateRender < Timber::Event
       attr_reader :message, :name, :time_ms
 

data/lib/timber/frameworks/rails.rb

@@ -4,19 +4,44 @@ module Timber
       # Installs Timber into your Rails app automatically.
       class Railtie < ::Rails::Railtie
         config.timber = Config.instance
-        config.before_initialize do
-          Probes.insert!
-          Timber::Frameworks::Rails.insert_middlewares(config.app_middleware)
+
+        initializer(:timber_logger, before: :initialize_logger) do
+          Rails.configure_middlewares(config.app_middleware)
+          Integrations.integrate!
+
+          # We set a default logger because Rails tries to write to a file by default.
+          # This causes errors on paltforms with a readon only file system (Heroku)
+          # Moreover, the Timber logger gets configured properly later in an initiailizer.
+          # This is a hold over until we reach that file in the initialization process.
+          logger = if defined?(::ActiveSupport::Logger)
+            ::ActiveSupport::Logger.new(STDOUT)
+          else
+            ::Logger.new(STDOUT)
+          end
+          ::Rails.logger = Config.instance.logger = logger
         end
       end
 
-      def self.insert_middlewares(middleware)
+      def self.set_logger(logger)
+        if defined?(::ActiveSupport::TaggedLogging) && !logger.is_a?(::ActiveSupport::TaggedLogging)
+          logger = ::ActiveSupport::TaggedLogging.new(logger)
+        end
+
+        Config.instance.logger = logger
+        ::ActionController::Base.logger = logger
+        ::ActionView::Base.logger = logger if ::ActionView::Base.respond_to?(:logger=)
+        ::ActiveRecord::Base.logger = logger
+        ::Rails.logger = logger
+      end
+
+      def self.configure_middlewares(middleware)
         var_name = :"@_timber_middlewares_inserted"
         return true if middleware.instance_variable_defined?(var_name) && middleware.instance_variable_get(var_name) == true
+
         # Rails uses a proxy :/, so we need to do this instance variable hack
         middleware.instance_variable_set(var_name, true)
-        Timber::RackMiddlewares.middlewares.each do |m|
-          middleware.insert_before ::Rails::Rack::Logger, m
+        Integrations::Rack.middlewares.each do |middleware_class|
+          middleware.use middleware_class
         end
       end
     end

data/lib/timber/integrations.rb

@@ -0,0 +1,22 @@
+require "timber/integrations/action_controller/log_subscriber"
+require "timber/integrations/action_dispatch/debug_exceptions"
+require "timber/integrations/action_view/log_subscriber"
+require "timber/integrations/active_record/log_subscriber"
+require "timber/integrations/active_support/tagged_logging"
+require "timber/integrations/rack"
+require "timber/integrations/rails/rack_logger"
+
+module Timber
+  # Namespace for all integrations.
+  # @private
+  module Integrations
+    def self.integrate!
+      ActionController::LogSubscriber.integrate!
+      ActionDispatch::DebugExceptions.integrate!
+      ActionView::LogSubscriber.integrate!
+      ActiveRecord::LogSubscriber.integrate!
+      ActiveSupport::TaggedLogging.integrate!
+      Rails::RackLogger.integrate!
+    end
+  end
+end

data/lib/timber/integrations/action_controller/log_subscriber.rb

@@ -0,0 +1,25 @@
+module Timber
+  module Integrations
+    module ActionController
+      # Responsible for removing the default ActionController::LogSubscriber and installing
+      # the TimberLogSubscriber
+      #
+      # @private
+      class LogSubscriber < Integrator
+        def initialize
+          require "action_controller/log_subscriber"
+          require "timber/integrations/action_controller/log_subscriber/timber_log_subscriber"
+        rescue LoadError => e
+          raise RequirementNotMetError.new(e.message)
+        end
+
+        def integrate!
+          return true if Util::ActiveSupportLogSubscriber.subscribed?(:action_controller, TimberLogSubscriber)
+
+          Util::ActiveSupportLogSubscriber.unsubscribe!(:action_controller, ::ActionController::LogSubscriber)
+          TimberLogSubscriber.attach_to(:action_controller)
+        end
+      end
+    end
+  end
+end

data/lib/timber/integrations/action_controller/log_subscriber/timber_log_subscriber.rb

@@ -0,0 +1,40 @@
+module Timber
+  module Integrations
+    module ActionController
+      class LogSubscriber < Integrator
+        # 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.
+        #
+        # @private
+        class TimberLogSubscriber < ::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
+
+          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
+        end
+      end
+    end
+  end
+end

data/lib/timber/integrations/action_dispatch/debug_exceptions.rb

@@ -0,0 +1,51 @@
+module Timber
+  module Integrations
+    module ActionDispatch
+      # Reponsible for disabled logging in the ActionDispatch::DebugExceptions
+      # Rack middleware. We cannot simply remove the middleware because it is
+      # coupled with displaying an exception debug screen if debug exceptions is enabled.
+      #
+      # @private
+      class DebugExceptions < Integrator
+
+        # Patch for disabling logging
+        #
+        # @private
+        module InstanceMethods
+          def self.included(klass)
+            klass.class_eval do
+              private
+                def logger(*args)
+                  nil
+                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 integrate!
+          if defined?(::ActionDispatch::DebugExceptions) && !::ActionDispatch::DebugExceptions.include?(InstanceMethods)
+            ::ActionDispatch::DebugExceptions.send(:include, InstanceMethods)
+          end
+
+          if defined?(::ActionDispatch::ShowExceptions) && !::ActionDispatch::ShowExceptions.include?(InstanceMethods)
+            ::ActionDispatch::ShowExceptions.send(:include, InstanceMethods)
+          end
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/timber/integrations/action_view/log_subscriber.rb

@@ -0,0 +1,25 @@
+module Timber
+  module Integrations
+    module ActionView
+      # Reponsible for uninstalling the default `ActionView::LogSubscriber` and installing
+      # the TimberLogSubscriber.
+      #
+      # @private
+      class LogSubscriber < Integrator
+        def initialize
+          require "action_view/log_subscriber"
+          require "timber/integrations/action_view/log_subscriber/timber_log_subscriber"
+        rescue LoadError => e
+          raise RequirementNotMetError.new(e.message)
+        end
+
+        def integrate!
+          return true if Util::ActiveSupportLogSubscriber.subscribed?(:action_view, TimberLogSubscriber)
+
+          Util::ActiveSupportLogSubscriber.unsubscribe!(:action_view, ::ActionView::LogSubscriber)
+          TimberLogSubscriber.attach_to(:action_view)
+        end
+      end
+    end
+  end
+end

data/lib/timber/integrations/action_view/log_subscriber/timber_log_subscriber.rb

@@ -0,0 +1,73 @@
+module Timber
+  module Integrations
+    module ActionView
+      class LogSubscriber < Integrator
+
+        # 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.
+        #
+        # @private
+        class TimberLogSubscriber < ::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
+end