timberio 1.0.0.beta1 → 1.0.0

data/spec/timber/log_devices/heroku_logplex_spec.rb

@@ -1,45 +0,0 @@
-require "spec_helper"
-
-describe Timber::LogDevices::HerokuLogplex do
-  let(:io) { STDOUT }
-  let(:log_device) { described_class.new }
-
-  describe ".write" do
-    let(:time) { Time.utc(2016, 9, 1, 12, 0, 0) }
-
-    before(:each) do
-      server_context = Timber::CurrentContext.get(Timber::Contexts::Server)
-      allow(server_context).to receive(:_dt).and_return(time)
-    end
-
-    it "writes a proper logfmt line" do
-      expect(io).to receive(:write).with("\e7\e[1;30m@timber.io \e8\e[Kserver.hostname=comp\e8\e[Kuter-name.domain.com\e8\e[K server._dt=2016-09-\e8\e[K01T12:00:00.000000Z \e8\e[Kserver._version=1 se\e8\e[Krver._index=0 _versi\e8\e[Kon=1 _hierarchy=[ser\e8\e[Kver] @original \e8\e[K\e[0mthis is a message\n")
-      # Notice we do not have dt for the log line since Heroku provides this
-      log_device.write("this is a message\n")
-    end
-
-    context "with a heroku context" do
-      around(:each) do |example|
-        heroku = Timber::Contexts::Servers::HerokuSpecific.new("web.1")
-        Timber::CurrentContext.add(heroku) { example.run }
-      end
-
-      # No need for the heroku context since logplex includes that data by default
-      it "does not include the heroku context" do
-        expect(io).to receive(:write).with("\e7\e[1;30m@timber.io \e8\e[Kserver.hostname=comp\e8\e[Kuter-name.domain.com\e8\e[K server._dt=2016-09-\e8\e[K01T12:00:00.000000Z \e8\e[Kserver._version=1 se\e8\e[Krver._index=0 _versi\e8\e[Kon=1 _hierarchy=[ser\e8\e[Kver,server.heroku] @original \e8\e[K\e[0mthis is a message\n")
-        # Notice we do not have dt for the log line since Heroku provides this
-        log_device.write("this is a message\n")
-      end
-    end
-
-    context "with multiple lines" do |variable|
-      it "does not include the heroku context" do
-        expect(io).to receive(:write).with("\e7\e[1;30m@timber.io \e8\e[Kserver.hostname=comp\e8\e[Kuter-name.domain.com\e8\e[K server._dt=2016-09-\e8\e[K01T12:00:00.000000Z \e8\e[Kserver._version=1 se\e8\e[Krver._index=0 _versi\e8\e[Kon=1 _hierarchy=[ser\e8\e[Kver] @original \e8\e[K\e[0mline 1\n")
-        expect(io).to receive(:write).with("\e7\e[1;30m@timber.io \e8\e[Kserver.hostname=comp\e8\e[Kuter-name.domain.com\e8\e[K server._dt=2016-09-\e8\e[K01T12:00:00.000000Z \e8\e[Kserver._version=1 se\e8\e[Krver._index=1 _versi\e8\e[Kon=1 _hierarchy=[ser\e8\e[Kver] @original \e8\e[K\e[0mline 2\n")
-        expect(io).to receive(:write).with("\e7\e[1;30m@timber.io \e8\e[Kserver.hostname=comp\e8\e[Kuter-name.domain.com\e8\e[K server._dt=2016-09-\e8\e[K01T12:00:00.000000Z \e8\e[Kserver._version=1 se\e8\e[Krver._index=2 _versi\e8\e[Kon=1 _hierarchy=[ser\e8\e[Kver] @original \e8\e[K\e[0mline 3\n")
-        # Notice we do not have dt for the log line since Heroku provides this
-        log_device.write("line 1\nline 2\nline 3\n")
-      end
-    end
-  end
-end

data/spec/timber/log_devices/http/log_truck/delivery_spec.rb

@@ -1,66 +0,0 @@
-require "spec_helper"
-
-describe Timber::LogDevices::HTTP::LogTruck::Delivery do
-  describe "#deliver!" do
-    let(:time) { Time.utc(2016, 9, 1, 12, 0, 0) }
-
-    before(:each) { ActiveSupport.send(:silence_warnings) { described_class::RETRY_COUNT = 0 } }
-    after(:each) { ActiveSupport.send(:silence_warnings) { described_class::RETRY_COUNT = 3 } }
-
-    def new_stub
-      stub_request(:post, "https://timber-odin.herokuapp.com/agent_log_frames").
-        with(:body => "{\"agent_log_frame\": {\"log_lines\": [{\"dt\":\"2016-09-01T12:00:00.000000Z\",\"message\":\"hello\",\"context\":{\"server\":{\"hostname\":\"computer-name.domain.com\",\"_dt\":\"2016-09-01T12:00:00.000000Z\",\"_version\":1,\"_index\":0},\"_version\":1,\"_hierarchy\":[\"server\"]}}]}}",
-             :headers => {'Content-Type'=>'application/json'})
-    end
-
-    around(:each) do |example|
-      Timecop.freeze(time) { example.run }
-    end
-
-    before(:each) do
-      server_context = Timber::CurrentContext.get(Timber::Contexts::Server)
-      allow(server_context).to receive(:_dt).and_return(time)
-    end
-
-    let(:log_lines) { [Timber::LogLine.new("hello")] }
-    let(:delivery) { described_class.new(Timber::Config.application_key, log_lines) }
-    let(:stub) { new_stub }
-
-    before(:each) { stub }
-
-    it "should delivery successfully" do
-      delivery.deliver!
-      expect(stub).to have_been_requested
-    end
-
-    context "timeout error" do
-      let(:stub) {
-        new_stub.to_timeout
-      }
-
-      it "should raise an error" do
-        expect { delivery.deliver! }.to raise_error(Timber::LogDevices::HTTP::LogTruck::Delivery::DeliveryError)
-      end
-    end
-
-    context "random error" do
-      let(:stub) {
-        new_stub.to_raise(StandardError.new("some error"))
-      }
-
-      it "should raise an error" do
-        expect { delivery.deliver! }.to raise_error(Timber::LogDevices::HTTP::LogTruck::Delivery::DeliveryError)
-      end
-    end
-
-    context "internal server error" do
-      let(:stub) {
-        new_stub.to_return(status: [500, "Internal Server Error"])
-      }
-
-      it "should raise an error" do
-        expect { delivery.deliver! }.to raise_error(Timber::LogDevices::HTTP::LogTruck::Delivery::DeliveryError)
-      end
-    end
-  end
-end

data/spec/timber/log_devices/http/log_truck_spec.rb

@@ -1,65 +0,0 @@
-require "spec_helper"
-
-describe Timber::LogDevices::HTTP::LogTruck do
-  describe ".start!" do
-    it "spawns a new thread" do
-      expect(Thread).to receive(:new).once
-      described_class.start!
-    end
-
-    it "delivers" do
-      expect(described_class).to receive(:deliver).once
-      described_class.start! do |thread|
-        thread.kill
-      end.join
-    end
-  end
-
-  describe ".deliver" do
-    let(:log_pile) { Timber::LogDevices::HTTP::LogPile.get(Timber::Config.application_key) }
-
-    it "doesn't deliver because there is nothing to deliver" do
-      expect(log_pile).to_not receive(:deliver)
-      described_class.deliver
-    end
-
-    context "with a log pile" do
-      before(:each) do
-        log_line = Timber::LogLine.new("this is a log line")
-        log_pile.drop(log_line)
-      end
-
-      it "delivers once and empties the log pile" do
-        expect(log_pile.size).to eq(1)
-        expect_any_instance_of(described_class).to receive(:deliver!).once
-        described_class.deliver
-        expect(log_pile.size).to eq(0)
-      end
-    end
-  end
-
-  describe "#initialize" do
-    let(:log_lines) { [] }
-    let(:log_truck) { described_class.new(Timber::Config.application_key, log_lines) }
-    subject { log_truck }
-
-    it "should raise an exception" do
-      expect { subject }.to raise_exception(Timber::LogDevices::HTTP::LogTruck::NoPayloadError)
-    end
-
-    context "with log lines" do
-      let(:log_lines) { [Timber::LogLine.new("hello")] }
-      its(:log_lines) { should eq(log_lines) }
-    end
-  end
-
-  describe "#deliver!" do
-    let(:log_lines) { [Timber::LogLine.new("hello")] }
-    let(:log_truck) { described_class.new(Timber::Config.application_key, log_lines) }
-
-    it "should delivery successfully" do
-      expect_any_instance_of(Timber::LogDevices::HTTP::LogTruck::Delivery).to receive(:deliver!)
-      log_truck.deliver!
-    end
-  end
-end

data/spec/timber/log_devices/io/hybrid_hidden_formatter_spec.rb

@@ -1,28 +0,0 @@
-require "spec_helper"
-
-describe Timber::LogDevices::IO::HybridHiddenFormatter do
-  describe ".format" do
-    let(:time) { Time.utc(2016, 9, 1, 12, 0, 0) }
-    let(:formatter) { described_class.new }
-    let(:message) { "a message" }
-    let(:log_line) { Timber::LogLine.new(message) }
-    subject { formatter.format(log_line) }
-
-    before(:each) do
-      server_context = Timber::CurrentContext.get(Timber::Contexts::Server)
-      allow(server_context).to receive(:_dt).and_return(time)
-    end
-
-    it { should eq("\e7\e[1;30m@timber.io \e8\e[Kserver.hostname=comp\e8\e[Kuter-name.domain.com\e8\e[K server._dt=2016-09-\e8\e[K01T12:00:00.000000Z \e8\e[Kserver._version=1 se\e8\e[Krver._index=0 _versi\e8\e[Kon=1 _hierarchy=[ser\e8\e[Kver] @original \e8\e[K\e[0ma message") }
-
-    context "with a slash" do
-      let(:message) { "this is a long message that exceeds the step size".insert(described_class::CLEAR_STEP_SIZE - 1, "\\") }
-
-      before(:each) do
-        allow(formatter).to receive(:encoded_context).and_return(message)
-      end
-
-      it { should eq("\e7\e[1;30m@timber.io \e8\e[Kthis is a long mess\\a\e8\e[Kge that exceeds the \e8\e[Kstep size @original \e8\e[K\e[0mthis is a long mess\\a\e8\e[Kge that exceeds the \e8\e[Kstep size") }
-    end
-  end
-end

data/spec/timber/log_line_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-
-describe Timber::LogLine do
-  let(:message) { "this is a message" }
-  let(:log_line) { described_class.new(message) }
-
-  around(:each) do |example|
-    heroku = Timber::Contexts::Servers::HerokuSpecific.new("web.1")
-    Timber::CurrentContext.add(heroku) { example.run }
-  end
-
-  describe "#initialize" do
-    subject { log_line }
-
-    its(:dt) { should_not be_nil }
-    its(:message) { should equal(message) }
-
-    context "non string" do
-      let(:message) { :"this is a message" }
-      its(:message) { should eq(message.to_s) }
-    end
-
-    context "exceeds bytesize limit" do
-      let(:limit) { Timber::APISettings::MESSAGE_BYTE_SIZE_MAX }
-      let(:message) { (1..(limit + 1)).collect { "A" }.join }
-      its(:message) { should_not eq(message) }
-      its(:message) { should eq(message.byteslice(0, Timber::APISettings::MESSAGE_BYTE_SIZE_MAX)) }
-    end
-
-    it "notifies CurrentLineIndexes" do
-      expect(Timber::CurrentLineIndexes).to receive(:log_line_added).once
-      subject
-    end
-  end
-
-  describe "#to_json" do
-    # Note: very important that we keep the iso8601 format. Otherwise the Timber API
-    # will recognized the date as invalid.
-    let(:as_json) do
-      {
-        dt: log_line.dt.iso8601(6),
-        message: log_line.message,
-      }.merge(log_line.context_snapshot.as_json)
-    end
-    let(:json) { as_json.to_json }
-    subject { log_line.to_json }
-    it { should eq(json) }
-  end
-end

data/spec/timber/macros/compactor_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-
-describe Timber::Macros::Compactor do
-  describe ".compact" do
-    let(:hash) { {} }
-    subject { described_class.compact(hash) }
-    it { should eq({}) }
-
-    context "nested" do
-      let(:hash) { {:whatever => {:nested => nil}} }
-      it { should eq({}) }
-    end
-
-    context "nested with other values" do
-      let(:hash) { {:whatever => {:nested => nil, :with_val => 1}, :another => 1} }
-      it { should eq({:whatever => {:with_val => 1}, :another => 1}) }
-    end
-  end
-end

data/spec/timber/macros/logfmt_encoder_spec.rb

@@ -1,89 +0,0 @@
-require "spec_helper"
-
-describe Timber::Macros::LogfmtEncoder do
-  describe ".encode" do
-    subject { described_class.encode(target) }
-
-    context "nil" do
-      let(:target) { nil }
-      it "should raise" do
-        expect { subject }.to raise_error(ArgumentError)
-      end
-    end
-
-    context "blank hash" do
-      let(:target) { {} }
-      it { should eq("") }
-    end
-
-    context "simple hash" do
-      let(:target) { {"key" => "value"} }
-      it { should eq("key=value") }
-    end
-
-    context "with space in value" do
-      let(:target) { {"key" => "this is a value"} }
-      it { should eq("key=\"this is a value\"") }
-    end
-
-    context "with quote in value" do
-      let(:target) { {"key" => "value\"another"} }
-      it { should eq("key=\"value\\\"another\"") }
-    end
-
-    context "with a space in the key" do
-      let(:target) { {"this is a key" => "value"} }
-      it { should eq("\"this is a key\"=value") }
-    end
-
-    context "with a . in the key" do
-      let(:target) { {"this.is.a.key" => "value"} }
-      it { should eq("\"this.is.a.key\"=value") }
-    end
-
-    context "with a nested hash" do
-      let(:target) { {"key" => {"sub_key" => "value"}} }
-      it { should eq("key.sub_key=value") }
-    end
-
-    context "with a nested hash and space in the key" do
-      let(:target) { {"key" => {"sub key" => "value"}} }
-      it { should eq("key.\"sub key\"=value") }
-    end
-
-    context "with a nested hash and . in the key" do
-      let(:target) { {"key" => {"sub.key" => "value"}} }
-      it { should eq("key.\"sub.key\"=value") }
-    end
-
-    context "with an integer value" do
-      let(:target) { {"key" => 1} }
-      it { should eq("key=1") }
-    end
-
-    context "with a float value" do
-      let(:target) { {"key" => 1.23} }
-      it { should eq("key=1.23") }
-    end
-
-    context "with a true value" do
-      let(:target) { {"key" => true} }
-      it { should eq("key=true") }
-    end
-
-    context "with a false value" do
-      let(:target) { {"key" => false} }
-      it { should eq("key=false") }
-    end
-
-    context "with an array value" do
-      let(:target) { {"key" => ["this is a value",2,3]} }
-      it { should eq("key=[\"this is a value\",2,3]") }
-    end
-
-    context "with an array value that has a ," do
-      let(:target) { {"key" => ["this,is a value",2,3]} }
-      it { should eq("key=[\"this,is a value\",2,3]") }
-    end
-  end
-end

data/spec/timber/patterns/to_json_spec.rb

@@ -1,40 +0,0 @@
-require "spec_helper"
-
-describe Timber::Patterns::ToJSON do
-  class TestJSON
-    include Timber::Patterns::ToJSON
-
-    attr_reader :json_payload
-
-    def initialize(json_payload)
-      @json_payload = json_payload
-    end
-  end
-
-  describe ".as_json" do
-    let(:hash) { {} }
-    let(:target) { TestJSON.new(hash) }
-    subject { target.as_json }
-    it { should eq({}) }
-
-    context "with a value" do
-      let(:hash) { {:test => 1} }
-      it { should eq({:test => 1}) }
-    end
-
-    context "with a nil value" do
-      let(:hash) { {:test => nil} }
-      it { should eq({}) }
-    end
-
-    context "with an empty array" do
-      let(:hash) { {:test => []} }
-      it { should eq({}) }
-    end
-
-    context "with an empty hash" do
-      let(:hash) { {:test => {}} }
-      it { should eq({}) }
-    end
-  end
-end

data/spec/timber/probes/action_controller_base_spec.rb

@@ -1,43 +0,0 @@
-require "spec_helper"
-
-describe Timber::Probes::ActionControllerBase do
-  describe described_class::InstanceMethods do
-    before(:each) do
-      class PagesPlainController < ActionController::Base
-        layout nil
-
-        def index
-          render json: {}
-        end
-
-        def method_for_action(action_name)
-          action_name
-        end
-      end
-
-      ::RailsApp.routes.draw do
-        get 'pages_plain' => 'pages_plain#index'
-      end
-    end
-
-    after(:each) do
-      Object.send(:remove_const, :PagesPlainController)
-    end
-
-    let(:logger_context_class) { Timber::Contexts::Logger }
-    let(:rack_request_context_class) { Timber::Contexts::HTTPRequests::Rack }
-    let(:request_context_class) { Timber::Contexts::HTTPRequests::ActionControllerSpecific }
-    let(:organization_context_class) { Timber::Contexts::Organizations::ActionController }
-    let(:user_context_class) { Timber::Contexts::Users::ActionController }
-    let(:response_context_class) { Timber::Contexts::HTTPResponses::ActionController }
-
-    describe "#process" do
-      it "should set the context" do
-        allow(Timber::CurrentContext).to receive(:add).with(kind_of(logger_context_class))
-        expect(Timber::CurrentContext).to receive(:add).with(kind_of(rack_request_context_class)).and_yield.once
-        expect(Timber::CurrentContext).to receive(:add).with(kind_of(request_context_class), kind_of(organization_context_class), kind_of(user_context_class), kind_of(response_context_class)).and_yield.once
-        dispatch_rails_request("/pages_plain")
-      end
-    end
-  end
-end

data/spec/timber/probes/action_controller_log_subscriber/action_controller_spec.rb

@@ -1,35 +0,0 @@
-require "spec_helper"
-
-describe Timber::Probes::ActiveSupportLogSubscriber::ActionController do
-  before(:each) do
-    class PagesController < ActionController::Base
-      layout nil
-
-      def index
-        response.headers['Content-Length'] = "500"
-        render json: {}
-      end
-
-      def method_for_action(action_name)
-        action_name
-      end
-    end
-
-    ::RailsApp.routes.draw do
-      get 'pages' => 'pages#index'
-    end
-  end
-
-  after(:each) do
-    Object.send(:remove_const, :PagesController)
-  end
-
-  let(:response_context_class) { Timber::Contexts::HTTPResponses::ActionController }
-
-  describe "#process_action" do
-    it "should set the context" do
-      expect_any_instance_of(response_context_class).to receive(:event=).with(kind_of(ActiveSupport::Notifications::Event)).once
-      dispatch_rails_request("/pages")
-    end
-  end
-end

data/spec/timber/probes/action_controller_log_subscriber/action_view_spec.rb

@@ -1,44 +0,0 @@
-require "spec_helper"
-
-describe Timber::Probes::ActiveSupportLogSubscriber::ActionView do
-  before(:each) do
-    class UsersController < 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 'users' => 'users#index'
-    end
-  end
-
-  after(:each) do
-    Object.send(:remove_const, :UsersController)
-  end
-
-  let(:logger_context_class) { Timber::Contexts::Logger }
-  let(:rack_request_context_class) { Timber::Contexts::HTTPRequests::Rack }
-  let(:request_context_class) { Timber::Contexts::HTTPRequests::ActionControllerSpecific }
-  let(:organization_context_class) { Timber::Contexts::Organizations::ActionController }
-  let(:user_context_class) { Timber::Contexts::Users::ActionController }
-  let(:response_context_class) { Timber::Contexts::HTTPResponses::ActionController }
-  let(:action_view_context_class) { Timber::Contexts::TemplateRenders::ActionView }
-  let(:action_view_specific_context_class) { Timber::Contexts::TemplateRenders::ActionViewSpecific }
-
-  describe "#process_action" do
-    it "should set the context" do
-      allow(Timber::CurrentContext).to receive(:add).with(kind_of(logger_context_class))
-      expect(Timber::CurrentContext).to receive(:add).with(kind_of(rack_request_context_class)).and_yield.once
-      expect(Timber::CurrentContext).to receive(:add).with(kind_of(request_context_class), kind_of(organization_context_class), kind_of(user_context_class), kind_of(response_context_class)).and_yield.once
-      expect(Timber::CurrentContext).to receive(:add).with(kind_of(action_view_context_class), kind_of(action_view_specific_context_class)).and_yield.once
-      dispatch_rails_request("/users")
-    end
-  end
-end

data/spec/timber/probes/action_controller_log_subscriber/active_record_spec.rb

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-describe Timber::Probes::ActiveSupportLogSubscriber::ActiveRecord do
-  before(:each) { Timber::Probes::ActiveSupportLogSubscriber.insert! }
-
-  let(:logger_context_class) { Timber::Contexts::Logger }
-  let(:active_record_context_class) { Timber::Contexts::SQLQueries::ActiveRecord }
-  let(:active_record_specific_context_class) { Timber::Contexts::SQLQueries::ActiveRecordSpecific }
-
-  describe "#sql" do
-    context "log level debug" do
-      before(:each) do
-        @old_level = ::ActiveRecord::Base.logger.level
-        ::ActiveRecord::Base.logger.level = Logger::DEBUG
-      end
-
-      after(:each) { ::ActiveRecord::Base.logger.level = @old_level }
-
-      it "should set the context" do
-        expect(Timber::CurrentContext).to receive(:add).with(kind_of(logger_context_class)).and_yield.once
-        expect(Timber::CurrentContext).to receive(:add).with(kind_of(active_record_context_class), kind_of(active_record_specific_context_class)).and_yield.once
-        ActiveRecord::Base.connection.execute("select * from users")
-      end
-    end
-  end
-end

data/spec/timber/probes/logger_spec.rb

@@ -1,20 +0,0 @@
-require "spec_helper"
-
-describe Timber::Probes::Logger do
-  describe described_class::InstanceMethods do
-    describe ".add" do
-      let(:logger) { ::Logger.new(nil) }
-      let(:context_class) { Timber::Contexts::Logger }
-
-      it "should set the context" do
-        expect(Timber::CurrentContext).to receive(:add).with(kind_of(context_class)).and_yield.once
-        logger.info("test")
-      end
-
-      it "should ignore Config.logger" do
-        expect(Timber::CurrentContext).to_not receive(:add).with(kind_of(context_class))
-        Timber::Config.logger.info("text")
-      end
-    end
-  end
-end

data/spec/timber/probes/rack_spec.rb

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-describe Timber::Probes::Rack do
-  describe described_class::Middleware do
-    describe ".call" do
-      let(:app) do
-        Rack::Builder.new do
-          use Timber::Probes::Rack::Middleware
-          run lambda { |env|
-            [200, {'Content-Type' => 'text/plain'}, ['hello world']]
-          }
-        end
-      end
-      let(:context_class) { Timber::Contexts::HTTPRequests::Rack }
-
-      def request
-        Rack::MockRequest.new(app).get('/')
-      end
-
-      it "should set the context" do
-        expect(Timber::CurrentContext).to receive(:add).with(kind_of(context_class)).and_yield.once
-        request
-      end
-    end
-  end
-end