timber 1.1.14 → 2.0.0

data/spec/support/timber.rb

@@ -1,4 +1,3 @@
-# Must require last in order to be mocked via webmock
-require 'timber'
+require "timber"
 
-Timber::Config.instance.logger = ::Logger.new(STDOUT)
+Timber::Config.instance.debug_logger = ::Logger.new(STDOUT)

data/spec/support/webmock.rb

@@ -1,2 +1,3 @@
 require 'webmock/rspec'
+
 WebMock.disable_net_connect!

data/spec/timber/integrations/action_controller/log_subscriber_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+if defined?(::ActionController)
+  describe Timber::Integrations::ActionController::LogSubscriber do
+    let(:time) { Time.utc(2016, 9, 1, 12, 0, 0) }
+    let(:io) { StringIO.new }
+    let(:logger) do
+      logger = Timber::Logger.new(io)
+      logger.level = ::Logger::INFO
+      logger
+    end
+
+    describe "#insert!" do
+      around(:each) do |example|
+        class LogSubscriberController < ActionController::Base
+          layout nil
+
+          def index
+            render json: {}
+          end
+
+          def method_for_action(action_name)
+            action_name
+          end
+        end
+
+        ::RailsApp.routes.draw do
+          get 'log_subscriber' => 'log_subscriber#index'
+        end
+
+        with_rails_logger(logger) do
+          Timecop.freeze(time) { example.run }
+        end
+
+        Object.send(:remove_const, :LogSubscriberController)
+      end
+
+      it "should log a controller_call event once" do
+        # Rails uses this to calculate the view runtime below
+        allow(Benchmark).to receive(:ms).and_return(1).and_yield
+
+        dispatch_rails_request("/log_subscriber?query=value")
+        lines = clean_lines(io.string.split("\n"))
+        expect(lines.length).to eq(3)
+        expect(lines[1]).to start_with('Processing by LogSubscriberController#index as HTML\n  Parameters: {"query"=>"value"} @metadata {"level":"info","dt":"2016-09-01T12:00:00.000000Z"')
+        expect(lines[1]).to include('"event":{"server_side_app":{"controller_call":{"controller":"LogSubscriberController","action":"index","params_json":"{\"query\":\"value\"}"}}}')
+      end
+
+      # Remove blank lines since Rails does this to space out requests in the logs
+      def clean_lines(lines)
+        lines.select { |line| !line.start_with?(" @metadat") }
+      end
+    end
+  end
+end

data/spec/timber/integrations/action_dispatch/debug_exceptions_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+if defined?(::ActionDispatch)
+  describe Timber::Integrations::ActionDispatch::DebugExceptions do
+    let(:time) { Time.utc(2016, 9, 1, 12, 0, 0) }
+    let(:io) { StringIO.new }
+    let(:logger) do
+      logger = Timber::Logger.new(io)
+      logger.level = ::Logger::DEBUG
+      logger
+    end
+
+    describe "#insert!" do
+      around(:each) do |example|
+        class ExceptionController < ActionController::Base
+          layout nil
+
+          def index
+            raise "boom"
+          end
+
+          def method_for_action(action_name)
+            action_name
+          end
+        end
+
+        ::RailsApp.routes.draw do
+          get 'exception' => 'exception#index'
+        end
+
+        with_rails_logger(logger) do
+          Timecop.freeze(time) { example.run }
+        end
+
+        Object.send(:remove_const, :ExceptionController)
+      end
+
+      it "should log an exception event once" do
+        expect { dispatch_rails_request("/exception") }.to raise_error(RuntimeError)
+
+        lines = clean_lines(io.string.split("\n"))
+        expect(lines.length).to eq(3)
+        expect(lines[2]).to start_with('RuntimeError (boom) @metadata {"level":"fatal",')
+        expect(lines[2]).to include("\"event\":{\"server_side_app\":{\"exception\":{\"name\":\"RuntimeError\",\"message\":\"boom\",\"backtrace\":[")
+      end
+
+      # Remove blank lines since Rails does this to space out requests in the logs
+      def clean_lines(lines)
+        lines.select { |line| !line.start_with?(" @metadat") }
+      end
+    end
+  end
+end

data/spec/timber/integrations/action_view/log_subscriber_spec.rb

@@ -0,0 +1,115 @@
+require "spec_helper"
+
+if defined?(::ActionView)
+  describe Timber::Integrations::ActionView::LogSubscriber do
+    let(:time) { Time.utc(2016, 9, 1, 12, 0, 0) }
+    let(:io) { StringIO.new }
+    let(:logger) do
+      logger = Timber::Logger.new(io)
+      logger.level = ::Logger::WARN
+      logger
+    end
+
+    describe "insert!" do
+      around(:each) do |example|
+        class ActionViewLogSubscriberController < ActionController::Base
+          layout nil
+
+          def index
+            render template: "template"
+          end
+
+          def method_for_action(action_name)
+            action_name
+          end
+        end
+
+        ::RailsApp.routes.draw do
+          get 'action_view_log_subscriber' => 'action_view_log_subscriber#index'
+        end
+
+        with_rails_logger(logger) do
+          Timecop.freeze(time) { example.run }
+        end
+
+        Object.send(:remove_const, :ActionViewLogSubscriberController)
+      end
+
+      describe "#render_template" do
+        it "should not log if the level is not sufficient" do
+          dispatch_rails_request("/action_view_log_subscriber")
+          expect(io.string).to eq("")
+        end
+
+        context "with an info level" do
+          around(:each) do |example|
+            old_level = logger.level
+            logger.level = ::Logger::INFO
+            example.run
+            logger.level = old_level
+          end
+
+          it "should log a template render event once" do
+            dispatch_rails_request("/action_view_log_subscriber")
+            lines = clean_lines(io.string.split("\n"))
+            expect(lines[2].strip).to start_with("Rendered spec/support/rails/templates/template.html (0.0ms) @metadata {\"level\":\"info\"")
+            expect(lines[2]).to include("\"event\":{\"server_side_app\":{\"template_render\":{\"name\":\"spec/support/rails/templates/template.html\",\"time_ms\":0.0}}},")
+          end
+        end
+      end
+    end
+
+    if defined?(described_class::TimberLogSubscriber)
+      describe described_class::TimberLogSubscriber do
+        let(:event) do
+          event = Struct.new(:duration, :payload)
+          event.new(2, identifier: "path/to/template.html")
+        end
+
+        around(:each) do |example|
+          old_level = logger.level
+          logger.level = ::Logger::INFO
+          example.run
+          logger.level = old_level
+        end
+
+        describe "#render_template" do
+          it "should render the collection" do
+            log_subscriber = described_class.new
+            allow(log_subscriber).to receive(:logger).and_return(logger)
+            log_subscriber.render_template(event)
+            expect(io.string.strip).to start_with("Rendered path/to/template.html (2.0ms) @metadata")
+          end
+        end
+
+        describe "#render_partial" do
+          it "should render the collection" do
+            log_subscriber = described_class.new
+            allow(log_subscriber).to receive(:logger).and_return(logger)
+            log_subscriber.render_partial(event)
+            expect(io.string.strip).to start_with("Rendered path/to/template.html (2.0ms) @metadata")
+          end
+        end
+
+        describe "#render_collection" do
+          it "should render the collection" do
+            log_subscriber = described_class.new
+            allow(log_subscriber).to receive(:logger).and_return(logger)
+            log_subscriber.render_collection(event)
+
+            if log_subscriber.respond_to?(:render_count, true)
+              expect(io.string.strip).to start_with("Rendered collection of path/to/template.html [ times] (2.0ms) @metadata ")
+            else
+              expect(io.string.strip).to start_with("Rendered path/to/template.html (2.0ms) @metadata")
+            end
+          end
+        end
+      end
+    end
+
+    # Remove blank lines since Rails does this to space out requests in the logs
+    def clean_lines(lines)
+      lines.select { |line| !line.start_with?(" @metadata") }
+    end
+  end
+end

data/spec/timber/integrations/active_record/log_subscriber_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+if defined?(::ActiveRecord)
+  describe Timber::Integrations::ActiveRecord::LogSubscriber do
+    let(:time) { Time.utc(2016, 9, 1, 12, 0, 0) }
+    let(:io) { StringIO.new }
+    let(:logger) do
+      logger = Timber::Logger.new(io)
+      logger.level = ::Logger::INFO
+      logger
+    end
+
+    describe "#insert!" do
+      around(:each) do |example|
+        with_rails_logger(logger) do
+          Timecop.freeze(time) { example.run }
+        end
+      end
+
+      it "should not log if the level is not sufficient" do
+        ActiveRecord::Base.connection.execute("select * from users")
+        expect(io.string).to eq("")
+      end
+
+      context "with an info level" do
+        around(:each) do |example|
+          old_level = logger.level
+          logger.level = ::Logger::DEBUG
+          example.run
+          logger.level = old_level
+        end
+
+        it "should log the sql query" do
+          ActiveRecord::Base.connection.execute("select * from users")
+          # Rails 4.X adds random spaces :/
+          string = io.string.gsub("   ORDER BY", " ORDER BY")
+          string = string.gsub("  ORDER BY", " ORDER BY")
+          expect(string).to include("select * from users")
+          expect(string).to include("@metadata")
+          expect(string).to include("\"level\":\"debug\"")
+          expect(string).to include("\"event\":{\"server_side_app\":{\"sql_query\"")
+        end
+      end
+    end
+  end
+end

data/spec/timber/integrations/rack/http_context_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+if defined?(::Rack)
+  describe Timber::Integrations::Rack::HTTPContext do
+    let(:time) { Time.utc(2016, 9, 1, 12, 0, 0) }
+    let(:io) { StringIO.new }
+    let(:logger) do
+      logger = Timber::Logger.new(io)
+      logger.level = ::Logger::INFO
+      logger
+    end
+
+    around(:each) do |example|
+      class RackHttpController < ActionController::Base
+        layout nil
+
+        def index
+          Thread.current[:_timber_context_snapshot] = Timber::CurrentContext.instance.snapshot
+          render json: {}
+        end
+
+        def method_for_action(action_name)
+          action_name
+        end
+      end
+
+      ::RailsApp.routes.draw do
+        get '/rack_http' => 'rack_http#index'
+      end
+
+      with_rails_logger(logger) do
+        Timecop.freeze(time) { example.run }
+      end
+
+      Object.send(:remove_const, :RackHttpController)
+    end
+
+    describe "#process" do
+      it "should set the context" do
+        allow(Benchmark).to receive(:ms).and_return(1).and_yield
+
+        dispatch_rails_request("/rack_http")
+        http_context = Thread.current[:_timber_context_snapshot][:http]
+
+        expect(http_context).to eq({:method=>"GET", :path=>"/rack_http", :remote_addr=>"123.456.789.10", :request_id=>"unique-request-id-1234"})
+
+        lines = clean_lines(io.string.split("\n"))
+        expect(lines.length).to eq(3)
+        lines.each do |line|
+          expect(line).to include("\"http\":{\"method\":\"GET\",\"path\":\"/rack_http\",\"remote_addr\":\"123.456.789.10\",\"request_id\":\"unique-request-id-1234\"}")
+        end
+      end
+    end
+
+    # Remove blank lines since Rails does this to space out requests in the logs
+    def clean_lines(lines)
+      lines.select { |line| !line.start_with?(" @metadat") }
+    end
+  end
+end

data/spec/timber/integrations/rails/rack_logger_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+if defined?(::Rails)
+  describe Timber::Integrations::Rails::RackLogger do
+    describe described_class::InstanceMethods do
+      let(:time) { Time.utc(2016, 9, 1, 12, 0, 0) }
+      let(:io) { StringIO.new }
+      let(:logger) do
+        logger = Timber::Logger.new(io)
+        logger.level = ::Logger::INFO
+        logger
+      end
+
+      around(:each) do |example|
+        class RailsRackLoggerController < ActionController::Base
+          layout nil
+
+          def index
+            render json: {}
+          end
+
+          def method_for_action(action_name)
+            action_name
+          end
+        end
+
+        ::RailsApp.routes.draw do
+          get '/rails_rack_logger' => 'rails_rack_logger#index'
+        end
+
+        with_rails_logger(logger) do
+          Timecop.freeze(time) { example.run }
+        end
+
+        Object.send(:remove_const, :RailsRackLoggerController)
+      end
+
+      describe "#started_request_message" do
+        it "should mute the default rails logs" do
+          allow(::Rails).to receive(:env).and_return(ActiveSupport::StringInquirer.new("production")) # Rails 3.2.X
+
+          dispatch_rails_request("/rails_rack_logger")
+
+          lines = clean_lines(io.string.split("\n"))
+          expect(lines.length).to eq(3)
+          expect(lines[0]).to start_with("Started GET \"/rails_rack_logger\" @metadata")
+          expect(lines[1]).to start_with("Processing by RailsRackLoggerController#index as HTML @metadata")
+          expect(lines[2]).to start_with("Completed 200 OK in 0.0ms @metadata")
+        end
+      end
+    end
+
+    # Remove blank lines since Rails does this to space out requests in the logs
+    def clean_lines(lines)
+      lines.select { |line| !line.start_with?(" @metadat") }
+    end
+  end
+end

data/spec/timber/logger_spec.rb

@@ -58,17 +58,17 @@ describe Timber::Logger, :rails_23 => true do
       end
 
       it "should allow :time_ms" do
-        logger.info(message: "event complete", time_ms: 54.5)
+        logger.info("event complete", time_ms: 54.5)
         expect(io.string).to include("\"time_ms\":54.5")
       end
 
       it "should allow :tag" do
-        logger.info(message: "event complete", tag: "tag1")
+        logger.info("event complete", tag: "tag1")
         expect(io.string).to include("\"tags\":[\"tag1\"]")
       end
 
       it "should allow :tags" do
-        logger.info(message: "event complete", tags: ["tag1", "tag2"])
+        logger.info("event complete", tags: ["tag1", "tag2"])
         expect(io.string).to include("\"tags\":[\"tag1\",\"tag2\"]")
       end
 
@@ -119,17 +119,53 @@ describe Timber::Logger, :rails_23 => true do
   end
 
   describe "#formatter=" do
+    it "should not allow changing the formatter when the device is HTTP" do
+      http_device = Timber::LogDevices::HTTP.new("api_key")
+      logger = Timber::Logger.new(http_device)
+      expect { logger.formatter = ::Logger::Formatter.new }.to raise_error(ArgumentError)
+    end
+
+    it "should set the formatter" do
+      logger = Timber::Logger.new(STDOUT)
+      formatter = ::Logger::Formatter.new
+      logger.formatter = formatter
+      expect(logger.formatter).to eq(formatter)
+    end
+  end
+
+  describe "#info" do
+    let(:io) { StringIO.new }
+    let(:logger) { Timber::Logger.new(io) }
+
+    it "should allow default usage" do
+      logger.info("message")
+      expect(io.string).to start_with("message @metadata")
+      expect(io.string).to include('"level":"info"')
+    end
+
+    it "should allow messages with options" do
+      logger.info("message", tag: "tag")
+      expect(io.string).to start_with("message @metadata")
+      expect(io.string).to include('"level":"info"')
+      expect(io.string).to include('"tags":["tag"]')
+    end
+  end
+
+  describe "#error" do
     let(:io) { StringIO.new }
     let(:logger) { Timber::Logger.new(io) }
 
-    it "should not allow non Timber::Logger::Formatter formatters" do
-      logger.formatter = ::Logger::Formatter.new
-      expect(logger.formatter).to be_kind_of(::Timber::Logger::HybridFormatter)
+    it "should allow default usage" do
+      logger.error("message")
+      expect(io.string).to start_with("message @metadata")
+      expect(io.string).to include('"level":"error"')
     end
 
-    it "should allow Timber::Logger::Formatter formatters" do
-      logger.formatter = ::Timber::Logger::JSONFormatter.new
-      expect(logger.formatter).to be_kind_of(::Timber::Logger::JSONFormatter)
+    it "should allow messages with options" do
+      logger.error("message", tag: "tag")
+      expect(io.string).to start_with("message @metadata")
+      expect(io.string).to include('"level":"error"')
+      expect(io.string).to include('"tags":["tag"]')
     end
   end
 end