timber 2.6.2 → 3.0.0

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

@@ -1,115 +0,0 @@
-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\":{\"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

@@ -1,46 +0,0 @@
-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\":{\"sql_query\"")
-        end
-      end
-    end
-  end
-end

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

@@ -1,63 +0,0 @@
-require "spec_helper"
-
-if defined?(::Rack)
-  describe Timber::Integrations::Rack::ErrorEvent 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 RackErrorController < ActionController::Base
-        layout nil
-
-        hook_name = respond_to?(:before_action) ? "before_action" : "before_filter"
-        send(hook_name) do
-          raise "Boom!"
-        end
-
-        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_error' => 'rack_error#index'
-      end
-
-      with_rails_logger(logger) do
-        Timecop.freeze(time) { example.run }
-      end
-
-      Object.send(:remove_const, :RackErrorController)
-    end
-
-    describe "#process" do
-      it "should log the exception" do
-        allow(Benchmark).to receive(:ms).and_return(1).and_yield
-
-        expect { dispatch_rails_request("/rack_error") }.to raise_error(RuntimeError)
-
-        lines = clean_lines(io.string.split("\n"))
-        expect(lines.length).to eq(3)
-
-        expect(lines[0]).to start_with("Started GET \"/rack_error\" @metadata ")
-        expect(lines[1]).to start_with("Processing by RackErrorController#index as HTML @metadata ")
-        expect(lines[2]).to start_with("RuntimeError (Boom!) @metadata")
-      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/rack/http_context_spec.rb

@@ -1,60 +0,0 @@
-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({:host => "example.org", :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\":{\"host\":\"example.org\",\"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/rack/http_events_spec.rb

@@ -1,101 +0,0 @@
-require "spec_helper"
-
-if defined?(::Rack)
-  describe Timber::Integrations::Rack::HTTPEvents 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 log the events" do
-        allow(Benchmark).to receive(:ms).and_return(1).and_yield
-
-        dispatch_rails_request("/rack_http")
-
-        lines = clean_lines(io.string.split("\n"))
-        expect(lines.length).to eq(3)
-
-        expect(lines[0]).to start_with("Started GET \"/rack_http\" @metadata ")
-        expect(lines[1]).to start_with("Processing by RackHttpController#index as HTML @metadata ")
-        expect(lines[2]).to start_with("Completed 200 OK in 0.0ms @metadata ")
-      end
-
-      context "with the route silenced" do
-        around(:each) do |example|
-          described_class.silence_request = lambda do |rack_env, rack_request|
-            rack_request.path == "/rack_http"
-          end
-
-          example.run
-
-          described_class.silence_request = nil
-        end
-
-        it "should silence the logs" do
-          allow(Benchmark).to receive(:ms).and_return(1).and_yield
-
-          dispatch_rails_request("/rack_http")
-
-          lines = clean_lines(io.string.split("\n"))
-          expect(lines.length).to eq(0)
-        end
-      end
-
-      context "collapsed into a single event" do
-        around(:each) do |example|
-          described_class.collapse_into_single_event = true
-
-          example.run
-
-          described_class.collapse_into_single_event = nil
-        end
-
-        it "should silence the logs" do
-          allow(Benchmark).to receive(:ms).and_return(1).and_yield
-
-          dispatch_rails_request("/rack_http")
-
-          lines = clean_lines(io.string.split("\n"))
-          expect(lines.length).to eq(2)
-
-          expect(lines[0]).to start_with("Processing by RackHttpController#index as HTML @metadata ")
-          expect(lines[1]).to start_with("GET /rack_http completed with 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/integrations/rack/session_context_spec.rb

@@ -1,62 +0,0 @@
-require "spec_helper"
-
-if defined?(::Rack)
-  describe Timber::Integrations::Rack::SessionContext 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
-
-        expect_any_instance_of(described_class).to receive(:extract_from_cookie).exactly(1).times.and_return("1234")
-
-        dispatch_rails_request("/rack_http")
-        session_context = Thread.current[:_timber_context_snapshot][:session]
-
-        expect(session_context).to eq({:id => "1234"})
-
-        lines = clean_lines(io.string.split("\n"))
-        expect(lines.length).to eq(3)
-        lines.each do |line|
-          expect(line).to include("\"session\":{\"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