timber 1.1.14 → 2.0.0

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

@@ -0,0 +1,25 @@
+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 "active_record/log_subscriber"
+          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

@@ -0,0 +1,39 @@
+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)
+            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
+        end
+      end
+    end
+  end
+end

data/lib/timber/integrations/active_support/tagged_logging.rb

@@ -0,0 +1,71 @@
+module Timber
+  module Integrations
+      module ActiveSupport
+      # Reponsible for automatimcally tracking SQL query events in `ActiveRecord`, while still
+      # preserving the default log style.
+      #
+      # @private
+      class TaggedLogging < Integrator
+        # @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
+
+        def initialize
+          require "active_support/tagged_logging"
+        rescue LoadError => e
+          raise RequirementNotMetError.new(e.message)
+        end
+
+        def integrate!
+          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
+end

data/lib/timber/integrations/rack.rb

@@ -0,0 +1,16 @@
+require "timber/integrations/rack/exception_event"
+require "timber/integrations/rack/http_context"
+require "timber/integrations/rack/http_events"
+require "timber/integrations/rack/user_context"
+
+module Timber
+  module Integrations
+    module Rack
+      # All available 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, UserContext, HTTPEvents, ExceptionEvent]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Timber
+  module Integrations
+    module Rack
+      # Reponsible for capturing exceptions events within a Rack stack.
+      class ExceptionEvent
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          begin
+            status, headers, body = @app.call(env)
+          rescue Exception => exception
+            Config.instance.logger.fatal do
+              Events::Exception.new(
+                name: exception.class.name,
+                exception_message: exception.message,
+                backtrace: exception.backtrace
+              )
+            end
+
+            raise exception
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Timber
+  module Integrations
+    module Rack
+      # Reponsible for adding the HTTP context for applications that use `Rack`.
+      class HTTPContext
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          request = Util::Request.new(env)
+          context = Contexts::HTTP.new(
+            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

@@ -0,0 +1,46 @@
+module Timber
+  module Integrations
+    module Rack
+      # Reponsible for capturing and logging HTTP server requests and response events.
+      class HTTPEvents
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          start = Time.now
+          request = Util::Request.new(env)
+          body = Config.instance.capture_http_bodies? ? request.body_content : nil
+
+          Config.instance.logger.info do
+            Events::HTTPServerRequest.new(
+              body: body,
+              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
+            time_ms = (Time.now - start) * 1000.0
+            Events::HTTPServerResponse.new(
+              headers: headers,
+              request_id: request.request_id,
+              status: status,
+              time_ms: time_ms
+            )
+          end
+
+          [status, headers, body]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Timber
+  module Integrations
+    module Rack
+      # Reponsible for adding the user context.
+      class UserContext
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          user = get_user(env)
+          if user
+            context = Contexts::User.new(
+              id: user_id(user),
+              name: user_name(user),
+              email: user_email(user)
+            )
+            CurrentContext.with(context) do
+              @app.call(env)
+            end
+          else
+            @app.call(env)
+          end
+        end
+
+        private
+          def get_user(env)
+            if env['warden']
+              env['warden'].user
+            else
+              nil
+            end
+          end
+
+          def user_id(user)
+            user.respond_to?(:id) ? user.id : nil
+          end
+
+          def 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 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/rack_logger.rb

@@ -0,0 +1,49 @@
+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
+                # Rails 3.2 calls Rails.logger directly, so this is the first place
+                # we can mute the logger calls.
+                def started_request_message(*args)
+                  ""
+                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/integrator.rb

@@ -0,0 +1,24 @@
+module Timber
+  # Base class for `Timber::Integrations::*`.
+  #
+  # @private
+  class Integrator
+    class RequirementNotMetError < StandardError; end
+
+    class << self
+      def integrate!(*args)
+        new(*args).integrate!
+        Config.instance.debug_logger.debug("Integrated #{name}") if Config.instance.debug_logger
+        true
+      # RequirementUnsatisfiedError is the only silent failure we support
+      rescue RequirementNotMetError => e
+        Config.instance.debug_logger.debug("Failed integrating #{name}: #{e.message}") if Config.instance.debug_logger
+        false
+      end
+    end
+
+    def integrate!
+      raise NotImplementedError.new
+    end
+  end
+end

data/lib/timber/log_devices/http.rb

@@ -80,8 +80,6 @@ module Timber
       #   each HTTP payload. If the queue exceeds this limit an HTTP request will be issued. Bigger
       #   payloads mean higher throughput, but also use more memory. Timber will not accept
       #   payloads larger than 1mb.
-      # @option attributes [Symbol] :debug (false) Whether to print debug output or not. This is also
-      #   inferred from ENV['debug']. Output will be sent to `Timber::Config.logger`.
       # @option attributes [Symbol] :flush_interval (1) How often the client should
       #   attempt to deliver logs to the Timber API in fractional seconds. The HTTP client buffers
       #   logs and this options represents how often that will happen, assuming `:batch_byte_size`
@@ -105,8 +103,7 @@ module Timber
       #     request_queue: Timber::LogDevices::HTTP::DroppingSizedQueue.new(3))
       #   Timber::Logger.new(http_log_device)
       def initialize(api_key, options = {})
-        @api_key = api_key
-        @debug = options[:debug] || ENV['debug']
+        @api_key = api_key || raise(ArgumentError.new("The api_key parameter cannot be blank"))
         @timber_url = URI.parse(options[:timber_url] || ENV['TIMBER_URL'] || TIMBER_URL)
         @batch_size = options[:batch_size] || 1_000
         @flush_interval = options[:flush_interval] || 1 # 1 second
@@ -126,7 +123,7 @@ module Timber
       def write(msg)
         @msg_queue.enqueue(msg)
         if @msg_queue.full?
-          logger.debug("Flushing timber buffer via write") if debug?
+          debug_logger.debug("Flushing timber buffer via write") if debug_logger
           flush
         end
         true
@@ -140,8 +137,8 @@ module Timber
       end
 
       private
-        def debug?
-          !@debug.nil?
+        def debug_logger
+          Timber::Config.instance.debug_logger
         end
 
         def flush
@@ -163,7 +160,7 @@ module Timber
           loop do
             begin
               if intervaled_flush_ready?
-                logger.debug("Flushing timber buffer via the interval") if debug?
+                debug_logger.debug("Flushing timber buffer via the interval") if debug_logger
                 flush
               end
               sleep(0.1)
@@ -180,20 +177,20 @@ module Timber
         def outlet
           loop do
             http = Net::HTTP.new(@timber_url.host, @timber_url.port)
-            http.set_debug_output(logger) if debug?
+            http.set_debug_output(debug_logger) if debug_logger
             http.use_ssl = true if @timber_url.scheme == 'https'
             http.read_timeout = 30
             http.ssl_timeout = 10
             http.open_timeout = 10
 
             begin
-              logger.info("Starting Timber HTTP connection") if debug?
+              debug_logger.info("Starting Timber HTTP connection") if debug_logger
               http.start do |conn|
                 num_reqs = 0
                 while num_reqs < @requests_per_conn
-                  if debug?
-                    logger.debug("Waiting on next Timber request")
-                    logger.debug("Number of threads waiting on Timber request queue: #{@request_queue.num_waiting}")
+                  if debug_logger
+                    debug_logger.debug("Waiting on next Timber request")
+                    debug_logger.debug("Number of threads waiting on Timber request queue: #{@request_queue.num_waiting}")
                   end
 
                   # Blocks waiting for a request.
@@ -203,19 +200,19 @@ module Timber
                   begin
                     resp = conn.request(req)
                   rescue => e
-                    logger.error("Timber request error: #{e.message}") if debug?
+                    debug_logger.error("Timber request error: #{e.message}") if debug_logger
                     next
                   ensure
                     @requests_in_flight -= 1
                   end
                   num_reqs += 1
-                  logger.debug("Timber request successful: #{resp.code}") if debug?
+                  debug_logger.debug("Timber request successful: #{resp.code}") if debug_logger
                 end
               end
             rescue => e
-              logger.error("Timber request error: #{e.message}") if debug?
+              debug_logger.error("Timber request error: #{e.message}") if debug_logger
             ensure
-              logger.debug("Finishing Timber HTTP connection") if debug?
+              debug_logger.debug("Finishing Timber HTTP connection") if debug_logger
               http.finish if http.started?
             end
           end
@@ -224,10 +221,6 @@ module Timber
         def authorization_payload
           @authorization_payload ||= "Basic #{Base64.urlsafe_encode64(@api_key).chomp}"
         end
-
-        def logger
-          Config.instance.logger
-        end
     end
   end
 end