timber 2.6.2 → 3.0.0

data/spec/timber/cli/installers/root_spec.rb

@@ -1,73 +0,0 @@
-# encoding: utf-8
-
-require "spec_helper"
-
-describe Timber::CLI::Installers::Root, :rails_23 => true do
-  let(:api_key) { "abcd1234" }
-  let(:app) do
-    attributes = {
-      "api_key" => api_key,
-      "environment" => "development",
-      "heroku_drain_url" => "http://drain.heroku.com",
-      "name" => "My Rails App",
-      "platform_type" => "other"
-    }
-    Timber::CLI::API::Application.new(attributes)
-  end
-  let(:api) { Timber::CLI::API.new(api_key) }
-  let(:input) { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:io) { Timber::CLI::IO.new(io_out: output, io_in: input) }
-  let(:installer) { described_class.new(io, api) }
-
-  describe ".run" do
-    it "should run properly" do
-      input.string = "y\n"
-
-      expect(installer).to receive(:run_sub_installer).with(app).exactly(1).times
-      expect(installer).to receive(:send_test_messages).exactly(1).times
-      expect(installer).to receive(:confirm_log_delivery).exactly(1).times
-      expect(installer).to receive(:wrap_up).with(app).exactly(1).times
-      expect(api).to receive(:event).with(:success).exactly(1).times
-      expect(installer).to receive(:collect_feedback).exactly(1).times
-
-      installer.run(app)
-    end
-  end
-
-  describe ".get_sub_installer" do
-    context "with Rails" do
-      around(:each) do |example|
-        if defined?(Rails)
-          example.run
-        else
-          Rails = true
-          example.run
-          Object.send(:remove_const, :Rails)
-        end
-      end
-
-      it "should return Rails" do
-        expect(installer.send(:get_sub_installer).class).to eq(Timber::CLI::Installers::Rails)
-      end
-    end
-
-    context "without Rails" do
-      around(:each) do |example|
-        if defined?(Rails)
-          OldRails = Rails
-          Object.send(:remove_const, :Rails)
-          example.run
-          Rails = OldRails
-          Object.send(:remove_const, :OldRails)
-        else
-          example.run
-        end
-      end
-
-      it "should return other" do
-        expect(installer.send(:get_sub_installer).class).to eq(Timber::CLI::Installers::Other)
-      end
-    end
-  end
-end

data/spec/timber/config_spec.rb

@@ -1,28 +0,0 @@
-require "singleton"
-require "spec_helper"
-
-describe Timber::Config, :rails_23 => true do
-  let(:config) { Timber::Config.send(:new) }
-
-  describe ".logrageify!" do
-    it "should logrageify" do
-      expect(Timber::Integrations::ActionController.silence?).to eq(false)
-      expect(Timber::Integrations::ActionView.silence?).to eq(false)
-      expect(Timber::Integrations::ActiveRecord.silence?).to eq(false)
-      expect(Timber::Integrations::Rack::HTTPEvents.collapse_into_single_event?).to eq(false)
-
-      config.logrageify!
-
-      expect(Timber::Integrations::ActionController.silence?).to eq(true)
-      expect(Timber::Integrations::ActionView.silence?).to eq(true)
-      expect(Timber::Integrations::ActiveRecord.silence?).to eq(true)
-      expect(Timber::Integrations::Rack::HTTPEvents.collapse_into_single_event?).to eq(true)
-
-      # Reset
-      Timber::Integrations::ActionController.silence = false
-      Timber::Integrations::ActionView.silence = false
-      Timber::Integrations::ActiveRecord.silence = false
-      Timber::Integrations::Rack::HTTPEvents.collapse_into_single_event = false
-    end
-  end
-end

data/spec/timber/contexts/custom_spec.rb

@@ -1,11 +0,0 @@
-require "spec_helper"
-
-describe Timber::Contexts::Custom, :rails_23 => true do
-  describe ".as_json" do
-    it "should coerce type into an atom" do
-      custom_context = described_class.new(:type => "my type", :data => {:key => "value"})
-      json = custom_context.as_json()
-      expect(json.keys.first).to eq(:"my type")
-    end
-  end
-end

data/spec/timber/contexts/organization_spec.rb

@@ -1,11 +0,0 @@
-require "spec_helper"
-
-describe Timber::Contexts::Organization, :rails_23 => true do
-  describe ".as_json" do
-    it "should coerce id into a string" do
-      user_context = described_class.new(:id => 1)
-      json = user_context.as_json()
-      expect(json[:id]).to eq("1")
-    end
-  end
-end

data/spec/timber/contexts/runtime_spec.rb

@@ -1,11 +0,0 @@
-require "spec_helper"
-
-describe Timber::Contexts::Runtime, :rails_23 => true do
-  describe ".as_json" do
-    it "should coerce vm_pid into an string" do
-      custom_context = described_class.new(:vm_pid => 1)
-      json = custom_context.as_json()
-      expect(json[:vm_pid]).to eq("1")
-    end
-  end
-end

data/spec/timber/contexts/system_spec.rb

@@ -1,11 +0,0 @@
-require "spec_helper"
-
-describe Timber::Contexts::System, :rails_23 => true do
-  describe ".as_json" do
-    it "should coerce pid into an integer" do
-      custom_context = described_class.new(:pid => "1")
-      json = custom_context.as_json()
-      expect(json[:pid]).to eq(1)
-    end
-  end
-end

data/spec/timber/contexts/user_spec.rb

@@ -1,11 +0,0 @@
-require "spec_helper"
-
-describe Timber::Contexts::User, :rails_23 => true do
-  describe ".as_json" do
-    it "should coerce id into a string" do
-      user_context = described_class.new(:id => 1)
-      json = user_context.as_json()
-      expect(json[:id]).to eq("1")
-    end
-  end
-end

data/spec/timber/contexts_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-
-describe Timber::Contexts, :rails_23 => true do
-  describe ".build" do
-    it "should build a Timber::Context" do
-      context = Timber::Contexts::Custom.new(
-        type: :build,
-        data: {version: "1.0.0"}
-      )
-      built_context = Timber::Contexts.build(context)
-      expect(built_context).to eq(context)
-    end
-
-    it "should use #to_timber_context" do
-      BuildContext = Struct.new(:version) do
-        def to_timber_context
-          Timber::Contexts::Custom.new(
-            type: :build,
-            data: respond_to?(:to_h) ? to_h : Timber::Util::Struct.to_hash(self)
-          )
-        end
-      end
-      built_context = Timber::Contexts.build(BuildContext.new("1.0.0"))
-      expect(built_context).to be_kind_of(Timber::Contexts::Custom)
-      expect(built_context.type).to eq(:build)
-      Object.send(:remove_const, :BuildContext)
-    end
-
-    it "should accept a properly structured hash" do
-      built_context = Timber::Contexts.build(build: {version: "1.0.0"})
-      expect(built_context).to be_kind_of(Timber::Contexts::Custom)
-      expect(built_context.type).to eq(:build)
-    end
-
-    it "should accept a struct" do
-      BuildContext = Struct.new(:version) do
-        def type; :build; end
-      end
-      built_context = Timber::Contexts.build(BuildContext.new("1.0.0"))
-      expect(built_context).to be_kind_of(Timber::Contexts::Custom)
-      expect(built_context.type).to eq(:build)
-      Object.send(:remove_const, :BuildContext)
-    end
-
-    it "should return nil for unsupported" do
-      expect(Timber::Contexts.build(1)).to be_nil
-    end
-  end
-end

data/spec/timber/event_spec.rb

@@ -1,10 +0,0 @@
-require "spec_helper"
-
-describe Timber::Event, :rails_23 => true do
-  describe "#to_s" do
-    it "should display the message" do
-      event = Timber::Events::Custom.new(message: "Build version 1.0.0", type: :build, data: {version: "1.0.0"})
-      expect(event.to_s).to eq("Build version 1.0.0")
-    end
-  end
-end

data/spec/timber/events/custom_spec.rb

@@ -1,36 +0,0 @@
-require "spec_helper"
-
-describe Timber::Events::Custom, :rails_23 => true do
-  describe ".to_hash" do
-    it "should coerce type into an atom" do
-      custom_event = described_class.new(:type => "my type", :message => "hello", :data => {:key => "value"})
-      hash = custom_event.to_hash()
-      expect(hash.keys.first).to eq(:"my type")
-    end
-
-    it "should coerce a Time into a float representing fractional milliseconds" do
-      timer = Timber::Timer.start
-      sleep(0.25)
-      custom_event = described_class.new(:type => :my_event, :message => "hello", :data => {:time_ms => timer})
-      expect(custom_event.message).to include("in ")
-      expect(custom_event.message).to end_with("ms")
-      data = custom_event.data
-      expect(data[:time_ms]).to be_kind_of(Float)
-      expect(data[:time_ms]).to be > 0.0
-    end
-  end
-
-  describe "#new" do
-    it "does not require data key" do
-      custom_event = described_class.new(:type => "my type", :message => "hello")
-    end
-  end
-
-  describe "#as_json" do
-    it "should render an empty data hash" do
-      custom_event = described_class.new(:type => "my type", :message => "hello")
-      hash = custom_event.as_json()
-      expect(hash).to eq({:custom => {:"my type" => {}}})
-    end
-  end
-end

data/spec/timber/events/http_request_spec.rb

@@ -1,32 +0,0 @@
-# encoding: UTF-8
-
-require "spec_helper"
-
-describe Timber::Events::HTTPRequest, :rails_23 => true do
-  describe ".initialize" do
-    it "should coerce content_length into an integer" do
-      event = described_class.new(:method => 'GET', :content_length => "123")
-      expect(event.content_length).to eq(123)
-    end
-
-    context "with a header filters" do
-      around(:each) do |example|
-        old_http_header_filters = Timber::Config.instance.http_header_filters
-        Timber::Config.instance.http_header_filters += ['api-key']
-        example.run
-        Timber::Config.instance.http_header_filters = old_http_header_filters
-      end
-
-      it "should sanitize headers when a config option is set" do
-        event = described_class.new(:headers => {'Api-Key' => 'abcde'}, :host => 'my.host.com', :method => 'GET', :path => '/path', :scheme => 'https')
-        expect(event.headers).to eq({'api-key' => '[sanitized]'})
-      end
-    end
-
-    it "should handle header encoding" do
-      referer = 'http://www.metrojobb.se/jobb/1013893-skadeadministratör'.force_encoding('ASCII-8BIT')
-      event = described_class.new(:headers => {'Referer' => referer}, :host => 'my.host.com', :method => 'GET', :path => '/path', :scheme => 'https')
-      expect(event.headers["referer"].encoding).to eq(::Encoding::UTF_8)
-    end
-  end
-end

data/spec/timber/events/http_response_spec.rb

@@ -1,12 +0,0 @@
-# encoding: UTF-8
-
-require "spec_helper"
-
-describe Timber::Events::HTTPResponse, :rails_23 => true do
-  describe ".initialize" do
-    it "should coerce content_length into an integer" do
-      event = described_class.new(:content_length => "123", :status => 200, :time_ms => 1)
-      expect(event.content_length).to eq(123)
-    end
-  end
-end

data/spec/timber/events_spec.rb

@@ -1,55 +0,0 @@
-require "spec_helper"
-
-describe Timber::Events, :rails_23 => true do
-  describe ".build" do
-    it "should build a Timber::Event" do
-      event = Timber::Events::Custom.new(
-        type: :payment_rejected,
-        message: "Payment rejected",
-        data: {customer_id: "abcd1234", amount: 100}
-      )
-      built_event = Timber::Events.build(event)
-      expect(built_event).to eq(event)
-    end
-
-    it "should use #to_timber_event" do
-      PaymentRejectedEvent = Struct.new(:customer_id, :amount) do
-        def to_timber_event
-          Timber::Events::Custom.new(
-            type: :payment_rejected,
-            message: "Payment rejected for #{customer_id}",
-            data: respond_to?(:to_h) ? to_h : hash
-          )
-        end
-      end
-      built_event = Timber::Events.build(PaymentRejectedEvent.new("abcd1234", 100))
-      expect(built_event).to be_kind_of(Timber::Events::Custom)
-      expect(built_event.type).to eq(:payment_rejected)
-      expect(built_event.message).to eq("Payment rejected for abcd1234")
-      Object.send(:remove_const, :PaymentRejectedEvent)
-    end
-
-    it "should accept a properly structured hash" do
-      built_event = Timber::Events.build({message: "Payment rejected", payment_rejected: {customer_id: "abcd1234", amount: 100}})
-      expect(built_event).to be_kind_of(Timber::Events::Custom)
-      expect(built_event.type).to eq(:payment_rejected)
-      expect(built_event.message).to eq("Payment rejected")
-    end
-
-    it "should accept a struct" do
-      PaymentRejectedEvent = Struct.new(:customer_id, :amount) do
-        def message; "Payment rejected for #{customer_id}"; end
-        def type; :payment_rejected; end
-      end
-      built_event = Timber::Events.build(PaymentRejectedEvent.new("abcd1234", 100))
-      expect(built_event).to be_kind_of(Timber::Events::Custom)
-      expect(built_event.type).to eq(:payment_rejected)
-      expect(built_event.message).to eq("Payment rejected for abcd1234")
-      Object.send(:remove_const, :PaymentRejectedEvent)
-    end
-
-    it "should return nil for unsupported" do
-      expect(Timber::Events.build(1)).to be_nil
-    end
-  end
-end

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

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

@@ -1,53 +0,0 @@
-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\":{\"error\":{\"name\":\"RuntimeError\",\"message\":\"boom\",\"backtrace_json\":\"[")
-      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