timberio 1.0.0.beta1

data/spec/support/simplecov.rb

@@ -0,0 +1,9 @@
+require 'simplecov'
+
+# save to CircleCI's artifacts directory if we're on CircleCI
+if ENV['CIRCLE_ARTIFACTS']
+  dir = File.join(ENV['CIRCLE_ARTIFACTS'], "coverage")
+  SimpleCov.coverage_dir(dir)
+end
+
+SimpleCov.start

data/spec/support/socket_hostname.rb

@@ -0,0 +1,12 @@
+require "socket"
+
+# Stub out the hostname for tests only. This can't use a normal stub in the
+# test life cycle since our test rails app is loaded once upon initialization.
+# In other words, the rails app gets loaded with the server context inserted
+# before any tests are run.
+
+class ::Socket
+  def self.gethostname
+    "computer-name.domain.com"
+  end
+end

data/spec/support/timber.rb

@@ -0,0 +1,23 @@
+# Must require last in order to be mocked via webmock
+require 'timber'
+
+# Config
+Timber::Config.tap do |config|
+  config.application_key = "my_key"
+  config.logger.level = ::Logger::FATAL
+end
+
+RSpec.configure do |config|
+  config.after(:each) do
+    Timber::CurrentLineIndexes.reset!
+    Timber::LogDevices::HTTP::LogPile.each { |log_pile| log_pile.empty }
+
+    # Reset permanent context caches since we mock, etc.
+    Timber::CurrentContext.send(:stack).each do |context|
+      context.instance_variable_set(:"@as_json", nil)
+      context.instance_variable_set(:"@json_payload", nil)
+      context.instance_variable_set(:"@to_json", nil)
+      context.instance_variable_set(:"@to_logfmt", nil)
+    end
+  end
+end

data/spec/support/timecop.rb

@@ -0,0 +1,3 @@
+require 'timecop'
+
+Timecop.safe_mode = true

data/spec/support/webmock.rb

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

data/spec/timber/bootstrap_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Timber::Bootstrap do
+  describe ".bootstrap!" do
+    let(:middleware) { Rack::Builder.new }
+    let(:insert_before) { ::Rails::Rack::Logger }
+
+    def self.it_should_not_bootstrap
+      it "should not bootstrap" do
+        expect(Timber::Probes).to_not receive(:insert!)
+        expect(described_class.bootstrap!(middleware, insert_before)).to be false
+      end
+    end
+
+    def self.it_should_bootstrap
+      it "should bootstrap" do
+        expect(Timber::Probes).to receive(:insert!).once
+        expect(described_class.bootstrap!(middleware, insert_before)).to be true
+      end
+    end
+
+    it_should_bootstrap
+
+    context "disabled" do
+      before(:each) { Timber::Config.enabled = false }
+      after(:each) { Timber::Config.enabled = true }
+
+      it_should_not_bootstrap
+    end
+  end
+end

data/spec/timber/context_snapshot_spec.rb

@@ -0,0 +1,10 @@
+require "spec_helper"
+
+describe Timber::ContextSnapshot do
+  describe "#initialize" do
+    it "only includes the valid stack" do
+      expect(Timber::CurrentContext).to receive(:valid_stack).once.and_return([])
+      described_class.new
+    end
+  end
+end

data/spec/timber/context_spec.rb

@@ -0,0 +1,4 @@
+require "spec_helper"
+
+describe Timber::Context do
+end

data/spec/timber/contexts/exception_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Timber::Contexts::Exception do
+  let(:exception) do
+    begin
+      raise StandardError.new("this is a message")
+    rescue Exception => e
+      e
+    end
+  end
+  let(:context) { described_class.new(exception) }
+
+  describe ".as_json" do
+    subject { context.as_json }
+    its([:exception, :backtrace]) { should_not be_nil }
+    its([:exception, :name]) { should eq("StandardError") }
+    its([:exception, :message]) { should eq("this is a message") }
+  end
+
+  describe ".backtrace" do
+    subject { context.backtrace }
+    its(:size) { should eq(5) }
+  end
+
+  describe ".name" do
+    subject { context.name }
+    it { should eq("StandardError") }
+  end
+
+  describe ".message" do
+    subject { context.message }
+    it { should eq("this is a message") }
+  end
+end

data/spec/timber/contexts/organizations/action_controller_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe Timber::Contexts::Organizations::ActionController do
+  around(:each) do |example|
+    class PagesController < ActionController::Base
+      layout nil
+
+      def index
+        render json: {}
+      end
+
+      def method_for_action(action_name)
+        action_name
+      end
+
+      private
+        def current_organization
+          # I want this to execute a query and test logging that query
+          Organization.first
+        end
+    end
+
+    example.run
+
+    Object.send(:remove_const, :PagesController)
+  end
+
+  let(:context) { described_class.new(PagesController.new) }
+
+  describe "#name" do
+    subject { context.name }
+    it { should be_nil }
+
+    context "with an organization" do
+      before(:each) { Organization.create!(name: "Timber") }
+      it { should eq("Timber") }
+
+      context "with an organization context" do
+        around(:each) do |example|
+          Timber::CurrentContext.add(context) do
+            example.run
+          end
+        end
+
+        it { should eq("Timber") }
+      end
+    end
+  end
+end

data/spec/timber/contexts/users/action_controller_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+describe Timber::Contexts::Users::ActionController do
+  around(:each) do |example|
+    class PagesController < ActionController::Base
+      layout nil
+
+      def index
+        render json: {}
+      end
+
+      def method_for_action(action_name)
+        action_name
+      end
+
+      private
+        def current_user
+          # I want this to execute a query and test logging that query
+          @user ||= User.first
+        end
+    end
+
+    example.run
+
+    Object.send(:remove_const, :PagesController)
+
+    Timber::Probes::ActiveSupportLogSubscriber.insert!
+  end
+
+  let(:context) { described_class.new(PagesController.new) }
+
+  describe "#email" do
+    subject { context.email }
+    it { should be_nil }
+
+    context "with a user" do
+      before(:each) { User.create!(email: "a@a.com") }
+      it { should eq("a@a.com") }
+
+      context "with a user context" do
+        around(:each) do |example|
+          Timber::CurrentContext.add(context) do
+            example.run
+          end
+        end
+
+        it { should eq("a@a.com") }
+
+        context "with a debug log level" do
+          around(:each) do |example|
+            old_level = ::Rails.logger.level
+            ::Rails.logger.level = ::Logger::DEBUG
+            example.run
+            ::Rails.logger.level = old_level
+          end
+
+          # If the user object is not cached, it will create an infinite loop.
+          # This is because getting the user executes a query, which in turn creates
+          # logs, with tries to grab the user again, etc.
+          it { should eq("a@a.com") }
+        end
+      end
+    end
+  end
+end

data/spec/timber/current_line_indexes_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Timber::CurrentLineIndexes do
+  def add_log_line
+    Timber::LogLine.new("test")
+  end
+
+  describe "#log_line_added" do
+    it "only includes the valid stack" do
+      expect(Timber::CurrentContext).to receive(:valid_stack).twice.and_return([])
+      add_log_line
+    end
+
+    context "with a context" do
+      let(:heroku_context) { Timber::Contexts::Servers::HerokuSpecific.new("web.1")}
+
+      around(:each) do |example|
+        Timber::CurrentContext.add(heroku_context) do
+          example.run
+        end
+      end
+
+      context "with a log line" do
+        before(:each) { add_log_line }
+
+        it "sets the context to 0" do
+          expect(described_class.indexes[heroku_context]).to eq(0)
+        end
+
+        context "with an additional log line" do
+          before(:each) { add_log_line }
+
+          it "increments properly" do
+            expect(described_class.indexes[heroku_context]).to eq(1)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/timber/frameworks/rails_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Timber::Frameworks::Rails do
+  # describe described_class::Railtie do
+  #   it "includes the initializer" do
+  #     expect(RailsApp.instance.initializers.collect { |i| i.name }).to include("timber.bootstrap")
+  #   end
+  # end
+end

data/spec/timber/log_devices/heroku_logplex_spec.rb

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,89 @@
+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