timber 2.6.2 → 3.0.0

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

@@ -1,83 +0,0 @@
-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)
-            return true if silence?
-
-            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)
-            return true if silence?
-
-            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)
-            return true if silence?
-
-            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
-
-            def silence?
-              ActionView.silence?
-            end
-        end
-      end
-    end
-  end
-end

data/lib/timber/integrations/active_record.rb

@@ -1,18 +0,0 @@
-require "timber/integration"
-require "timber/integrations/active_record/log_subscriber"
-
-module Timber
-  module Integrations
-    # Module for holding *all* ActiveRecord integrations. See {Integration} for
-    # configuration details for all integrations.
-    module ActiveRecord
-      extend Integration
-
-      def self.integrate!
-        return false if !enabled?
-
-        LogSubscriber.integrate!
-      end
-    end
-  end
-end

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

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

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

@@ -1,53 +0,0 @@
-# We require all of ActiveRecord because the #logger method in ::ActiveRecord::LogSubscriber
-# uses ActiveRecord::Base. We can't require active_record/base directly because ActiveRecord
-# does not require files properly and we receive unintialized constant errors.
-require "active_record"
-require "active_record/log_subscriber"
-
-require "timber/integrator"
-
-module Timber
-  module Integrations
-    module ActiveRecord
-      class LogSubscriber < Integrator
-        # 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.
-        #
-        # @private
-        class TimberLogSubscriber < ::ActiveRecord::LogSubscriber
-          def sql(event)
-            return true if silence?
-
-            r = super(event)
-
-            if @message
-              payload = event.payload
-              event = Events::SQLQuery.new(
-                sql: payload[:sql],
-                time_ms: event.duration,
-                message: @message
-              )
-
-              logger.debug event
-
-              @message = nil
-            end
-
-            r
-          end
-
-          private
-            def debug(message)
-              @message = message
-            end
-
-            def silence?
-              ActiveRecord.silence?
-            end
-        end
-      end
-    end
-  end
-end

data/lib/timber/integrations/rack.rb

@@ -1,27 +0,0 @@
-require "timber/integrations/rack/error_event"
-require "timber/integrations/rack/http_context"
-require "timber/integrations/rack/http_events"
-require "timber/integrations/rack/session_context"
-require "timber/integrations/rack/user_context"
-
-module Timber
-  module Integrations
-    module Rack
-      # Enable / disable all Rack middlewares with a single setting.
-      def self.enabled=(value)
-        ErrorEvent.enabled = value
-        HTTPContext.enabled = value
-        HTTPEvents.enabled = value
-        SessionContext.enabled = value
-        UserContext.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 ||= [HTTPContext, SessionContext, UserContext,
-          HTTPEvents, ErrorEvent].select(&:enabled?)
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-begin
-  # Rails 3.2 requires you to require all of Rails before requiring
-  # the exception wrapper.
-  require "rails"
-  require "action_dispatch/middleware/exception_wrapper"
-rescue Exception
-end
-
-require "timber/config"
-require "timber/events/error"
-require "timber/integrations/rack/middleware"
-require "timber/util"
-
-module Timber
-  module Integrations
-    module Rack
-      # A Rack middleware that is reponsible for capturing exception and error events
-      # {Timber::Events::Error}.
-      class ErrorEvent < 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/integrations/rack/http_context.rb

@@ -1,27 +0,0 @@
-require "timber/contexts/http"
-require "timber/current_context"
-require "timber/integrations/rack/middleware"
-require "timber/util"
-
-module Timber
-  module Integrations
-    module Rack
-      # A Rack middleware that is reponsible for adding the HTTP context {Timber::Contexts::HTTP}.
-      class HTTPContext < Middleware
-        def call(env)
-          request = Util::Request.new(env)
-          context = Contexts::HTTP.new(
-            host: request.host,
-            method: request.request_method,
-            path: request.path,
-            remote_addr: request.ip,
-            request_id: request.request_id
-          )
-          CurrentContext.with(context) do
-            @app.call(env)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,210 +0,0 @@
-require "set"
-
-require "timber/config"
-require "timber/contexts/http"
-require "timber/current_context"
-require "timber/events/http_request"
-require "timber/events/http_response"
-require "timber/integrations/rack/middleware"
-
-module Timber
-  module Integrations
-    module Rack
-      # A Rack middleware that is reponsible for capturing and logging HTTP server requests and
-      # response events. The {Events::HTTPRequest} and {Events::HTTPResponse} events
-      # respectively.
-      class HTTPEvents < Middleware
-        class << self
-          # Allows you to capture the HTTP request body, default is off (false).
-          #
-          # Capturing HTTP bodies can be extremely helpful when debugging issues,
-          # but please proceed with caution:
-          #
-          # 1. Capturing HTTP bodies can use quite a bit of data (this can be mitigated, see below)
-          # 2. The {Events::ControllerCall} event captures the parsed parmaters sent to
-          #    the controller. This is a parsed representation of the body, which is usually more
-          #    helpful and redundant to the body captured here.
-          #
-          # If you opt to capture bodies, you can also truncate the size to reduce the data
-          # captured. See {Events::HTTPRequest}.
-          #
-          # @example
-          #   Timber::Integrations::Rack::HTTPEvents.capture_request_body = true
-          def capture_request_body=(value)
-            @capture_request_body = value
-          end
-
-          # Accessor method for {#capture_request_body=}
-          def capture_request_body?
-            @capture_request_body == true
-          end
-
-          # Just like {#capture_request_body=} but for the {Events::HTTPResponse} event.
-          # Please see {#capture_request_body=} for more details. The documentation there also
-          # applies here.
-          def capture_response_body=(value)
-            @capture_response_body = value
-          end
-
-          # Accessor method for {#capture_response_body=}
-          def capture_response_body?
-            @capture_response_body == true
-          end
-
-          # Collapse both the HTTP request and response events into a single log line event.
-          # While we don't recommend this, it can help to reduce log volume if desired.
-          # The reason we don't recommend this, is because the logging service you use should
-          # not be so expensive that you need to strip out useful logs. It should also provide
-          # the tools necessary to properly search your logs and reduce noise. Such as viewing
-          # logs for a specific request.
-          #
-          # To provide an example. This setting turns this:
-          #
-          #   Started GET "/" for 127.0.0.1 at 2012-03-10 14:28:14 +0100
-          #   Completed 200 OK in 79ms (Views: 78.8ms | ActiveRecord: 0.0ms)
-          #
-          # Into this:
-          #
-          #   Get "/" sent 200 OK in 79ms
-          #
-          # The single event is still a {Timber::Events::HTTPResponse} event. Because
-          # we capture HTTP context, you still get the HTTP details, but you will not get
-          # all of the request details that the {Timber::Events::HTTPRequest} event would
-          # provide.
-          #
-          # @example
-          #   Timber::Integrations::Rack::HTTPEvents.collapse_into_single_event = true
-          def collapse_into_single_event=(value)
-            @collapse_into_single_event = value
-          end
-
-          # Accessor method for {#collapse_into_single_event=}.
-          def collapse_into_single_event?
-            @collapse_into_single_event == true
-          end
-
-          # This setting allows you to silence requests based on any conditions you desire.
-          # We require a block because it gives you complete control over how you want to
-          # silence requests. The first parameter being the traditional Rack env hash, the
-          # second being a [Rack Request](http://www.rubydoc.info/gems/rack/Rack/Request) object.
-          #
-          # @example
-          #   Integrations::Rack::HTTPEvents.silence_request = lambda do |rack_env, rack_request|
-          #     rack_request.path == "/_health"
-          #   end
-          def silence_request=(proc)
-            if proc && !proc.is_a?(Proc)
-              raise ArgumentError.new("The value passed to #silence_request must be a Proc")
-            end
-
-            @silence_request = proc
-          end
-
-          # Accessor method for {#silence_request=}
-          def silence_request
-            @silence_request
-          end
-        end
-
-        CONTENT_LENGTH_KEY = 'Content-Length'.freeze
-
-        def call(env)
-          request = Util::Request.new(env)
-
-          if silenced?(env, request)
-            if Config.instance.logger.respond_to?(:silence)
-              Config.instance.logger.silence do
-                @app.call(env)
-              end
-            else
-              @app.call(env)
-            end
-
-          elsif collapse_into_single_event?
-            start = Time.now
-
-            status, headers, body = @app.call(env)
-
-            Config.instance.logger.info do
-              http_context_key = Contexts::HTTP.keyspace
-              http_context = CurrentContext.fetch(http_context_key)
-              content_length = headers[CONTENT_LENGTH_KEY]
-              time_ms = (Time.now - start) * 1000.0
-
-              Events::HTTPResponse.new(
-                content_length: content_length,
-                headers: headers,
-                http_context: http_context,
-                request_id: request.request_id,
-                status: status,
-                time_ms: time_ms
-              )
-            end
-
-            [status, headers, body]
-
-          else
-            start = Time.now
-
-            Config.instance.logger.info do
-              event_body = capture_request_body? ? request.body_content : nil
-
-              Events::HTTPRequest.new(
-                body: event_body,
-                content_length: request.content_length,
-                headers: request.headers,
-                host: request.host,
-                method: request.request_method,
-                path: request.path,
-                port: request.port,
-                query_string: request.query_string,
-                request_id: request.request_id, # we insert this middleware after ActionDispatch::RequestId
-                scheme: request.scheme
-              )
-            end
-
-            status, headers, body = @app.call(env)
-
-            Config.instance.logger.info do
-              event_body = capture_response_body? ? body : nil
-              content_length = headers[CONTENT_LENGTH_KEY]
-              time_ms = (Time.now - start) * 1000.0
-
-              Events::HTTPResponse.new(
-                body: event_body,
-                content_length: content_length,
-                headers: headers,
-                request_id: request.request_id,
-                status: status,
-                time_ms: time_ms
-              )
-            end
-
-            [status, headers, body]
-          end
-        end
-
-        private
-          def capture_request_body?
-            self.class.capture_request_body?
-          end
-
-          def capture_response_body?
-            self.class.capture_response_body?
-          end
-
-          def collapse_into_single_event?
-            self.class.collapse_into_single_event?
-          end
-
-          def silenced?(env, request)
-            if !self.class.silence_request.nil?
-              self.class.silence_request.call(env, request)
-            else
-              false
-            end
-          end
-      end
-    end
-  end
-end