timberio 1.0.0.beta1 → 1.0.0

data/lib/timber/probes/rails_rack_logger.rb

@@ -0,0 +1,76 @@
+module Timber
+  module Probes
+    # Responsible for automatically tracking the http request events for applications
+    # that use `Rack`.
+    class RailsRackLogger < Probe
+      module InstanceMethods
+        def self.included(klass)
+          klass.class_eval do
+            protected
+              if klass.method_defined?(:started_request_message)
+                def started_request_message(request)
+                  http_request_event(request)
+                end
+              elsif klass.method_defined?(:before_dispatch)
+                def before_dispatch(env)
+                  request = ActionDispatch::Request.new(env)
+                  info do
+                    http_request_event(request)
+                  end
+                end
+              end
+
+              def http_request_event(request)
+                # No idea why rails 3.X returns a "/" :/
+                referrer = request.referer == "/" ? nil : request.referer
+                Events::HTTPRequest.new(
+                  host: request.host,
+                  method: request.request_method,
+                  path: request.filtered_path,
+                  port: request.port,
+                  query_params: request.GET,
+                  content_type: request.content_type,
+                  remote_addr: request.ip,
+                  referrer: referrer,
+                  request_id: request_id(request.env),
+                  user_agent: request.user_agent
+                )
+              end
+
+              def request_id(env)
+                env["X-Request-ID"] ||
+                  env["X-Request-Id"] ||
+                  env["action_dispatch.request_id"]
+              end
+          end
+        end
+      end
+
+      module BeforeDispatchInstanceMethods
+        def self.included(klass)
+          klass.class_eval do
+            protected
+              def before_dispatch(env)
+                request = ActionDispatch::Request.new(env)
+                path = request.filtered_path
+
+                info "\n\nStarted #{request.request_method} \"#{path}\" " \
+                     "for #{request.ip} at #{Time.now.to_default_s}"
+              end
+          end
+        end
+      end
+
+      def initialize
+        require "rails/rack/logger"
+      rescue LoadError => e
+        raise RequirementNotMetError.new(e.message)
+      end
+
+      def insert!
+        return true if ::Rails::Rack::Logger.include?(InstanceMethods)
+        ::Rails::Rack::Logger.send(:include, InstanceMethods)
+      end
+    end
+  end
+end

data/lib/timber/probes.rb

@@ -1,24 +1,21 @@
-require "timber/probes/action_controller_base"
+require "timber/probes/action_controller_log_subscriber"
 require "timber/probes/action_dispatch_debug_exceptions"
-require "timber/probes/active_support_log_subscriber"
-require "timber/probes/heroku"
-require "timber/probes/logger"
-require "timber/probes/rack"
-require "timber/probes/server"
+require "timber/probes/action_view_log_subscriber"
+require "timber/probes/active_record_log_subscriber"
+require "timber/probes/rack_http_context"
+require "timber/probes/rails_rack_logger"
 
 module Timber
+  # Namespace for all probes.
+  # @private
   module Probes
     def self.insert!(middleware, insert_before)
-      # Persistent probes. Order is relevant.
-      Server.insert!
-      Heroku.insert!
-
-      # Transient probes, sorted alphabetically
-      ActionControllerBase.insert!
+      ActionControllerLogSubscriber.insert!
       ActionDispatchDebugExceptions.insert!
-      ActiveSupportLogSubscriber.insert!
-      Logger.insert!
-      Rack.insert!(middleware, insert_before)
+      ActionViewLogSubscriber.insert!
+      ActiveRecordLogSubscriber.insert!
+      RackHTTPContext.insert!(middleware, insert_before)
+      RailsRackLogger.insert!
     end
   end
-end
+end

data/lib/timber/util/active_support_log_subscriber.rb

@@ -0,0 +1,33 @@
+module Timber
+  module Util
+    # @private
+    module ActiveSupportLogSubscriber
+      extend self
+
+      def find(component, type)
+        ActiveSupport::LogSubscriber.log_subscribers.find do |subscriber|
+          subscriber.class == type
+        end
+      end
+
+      def subscribed?(component, type)
+        !find(component, type).nil?
+      end
+
+      def unsubscribe(component, type)
+        subscriber = find(component, type)
+
+        if subscriber
+          events = subscriber.public_methods(false).reject { |method| method.to_s == 'call' }
+          events.each do |event|
+            ActiveSupport::Notifications.notifier.listeners_for("#{event}.#{component}").each do |listener|
+              if listener.instance_variable_get('@delegate') == subscriber
+                ActiveSupport::Notifications.unsubscribe listener
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/timber/util/hash.rb

@@ -0,0 +1,14 @@
+module Timber
+  module Util
+    # @private
+    module Hash
+      extend self
+
+      def compact(hash)
+        hash.select do |k, v|
+          v != nil && v != {} && v != []
+        end
+      end
+    end
+  end
+end

data/lib/timber/util.rb

@@ -0,0 +1,8 @@
+require "timber/util/active_support_log_subscriber"
+require "timber/util/hash"
+
+module Timber
+  # @private
+  module Util
+  end
+end

data/lib/timber/version.rb

@@ -1,3 +1,3 @@
 module Timber
-  VERSION = "1.0.0.beta1"
-end
+  VERSION = "1.0.0"
+end

data/lib/timber.rb

@@ -2,26 +2,21 @@
 require "json" # brings to_json to the core classes
 
 # Base (must come first, order matters)
-require "timber/macros"
-require "timber/patterns"
 require "timber/config"
 require "timber/context"
-require "timber/log_device"
+require "timber/event"
 require "timber/probe"
+require "timber/util"
 require "timber/version"
 
 # Other (sorted alphabetically)
-require "timber/api_settings"
-require "timber/bootstrap"
-require "timber/context_snapshot"
 require "timber/contexts"
 require "timber/current_context"
-require "timber/current_line_indexes"
-require "timber/internal_logger"
+require "timber/events"
 require "timber/log_devices"
-require "timber/log_line"
+require "timber/log_entry"
 require "timber/logger"
 require "timber/probes"
 
-# Load frameworks last
-require "timber/frameworks"
+# Load frameworks
+require "timber/frameworks"

data/spec/spec_helper.rb

@@ -15,10 +15,13 @@ require File.join(File.dirname(__FILE__), 'support', 'simplecov')
 require File.join(File.dirname(__FILE__), 'support', 'timecop')
 require File.join(File.dirname(__FILE__), 'support', 'webmock')
 require File.join(File.dirname(__FILE__), 'support', 'timber')
-require File.join(File.dirname(__FILE__), 'support', 'rails')
-require File.join(File.dirname(__FILE__), 'support', 'action_controller')
-require File.join(File.dirname(__FILE__), 'support', 'action_view')
-require File.join(File.dirname(__FILE__), 'support', 'active_record')
+
+if !ENV["RAILS_23"]
+  require File.join(File.dirname(__FILE__), 'support', 'rails')
+  require File.join(File.dirname(__FILE__), 'support', 'action_controller')
+  require File.join(File.dirname(__FILE__), 'support', 'action_view')
+  require File.join(File.dirname(__FILE__), 'support', 'active_record')
+end
 
 RSpec.configure do |config|
   config.color = true

data/spec/support/rails.rb

@@ -1,8 +1,9 @@
 require "rails"
 
-log_dev = Timber::LogDevices::IO.new
-Rails.logger = Timber::Logger.new(log_dev)
-Rails.logger.level = ::Logger::FATAL
+# Defualt the rails logger to nothing, each test shoould be
+# responsible for setting up the logger
+logger = ::Logger.new(nil)
+Rails.logger = logger
 
 class RailsApp < Rails::Application
   if ::Rails.version =~ /^3\./
@@ -12,17 +13,20 @@ class RailsApp < Rails::Application
   end
   config.active_support.deprecation = :stderr
   config.eager_load = false
-  config.log_level = :fatal
 end
 
 RailsApp.initialize!
 
 module Support
   module Rails
-    def dispatch_rails_request(path)
+    def dispatch_rails_request(path, additional_env_options = {})
       application = ::Rails.application
       env = application.respond_to?(:env_config) ? application.env_config.clone : application.env_defaults.clone
       env["rack.request.cookie_hash"] = {}.with_indifferent_access
+      env["REMOTE_ADDR"] = "123.456.789.10"
+      env["X-Request-Id"] = "unique-request-id-1234"
+      env["action_dispatch.request_id"] = env["X-Request-Id"]
+      env = env.merge(additional_env_options)
       ::Rack::MockRequest.new(application).get(path, env)
     end
   end

data/spec/support/timber.rb

@@ -1,23 +1,4 @@
 # 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
+Timber::Config.instance.logger = ::Logger.new(nil)

data/spec/timber/events_spec.rb

@@ -0,0 +1,55 @@
+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?(:hash) ? hash : to_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({type: :payment_rejected, message: "Payment rejected", data: {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/log_devices/http_spec.rb

@@ -0,0 +1,62 @@
+# require "spec_helper"
+
+# describe Timber::LogDevices::HTTP do
+#   # We have to define our own at_exit method, because the mocks and
+#   # everything are stripped out before. Otherwise it tries to issue
+#   # a request :(
+#   before(:each) do
+#     described_class.class_eval do
+#       def at_exit; true; end
+#     end
+#   end
+
+#   describe "#initialize" do
+#     it "should start a thread for delivery" do
+#       allow_any_instance_of(described_class).to receive(:at_exit).exactly(1).times.and_return(true)
+#       expect_any_instance_of(described_class).to receive(:deliver).exactly(2).times.and_return(true)
+#       http = described_class.new("MYKEY", frequency_seconds: 0.1)
+#       thread = http.instance_variable_get(:@delivery_thread)
+#       expect(thread).to be_alive
+#       sleep 0.25 # allow 2 iterations
+#       http.close
+#     end
+#   end
+
+#   describe "#write" do
+#     let(:http) { described_class.new("MYKEY") }
+#     let(:buffer) { http.instance_variable_get(:@buffer) }
+
+#     after(:each) { http.close }
+
+#     it "should buffer the messages" do
+#       http.write("test log message")
+#       expect(buffer.read).to eq("test log message")
+#     end
+#   end
+
+#   describe "#deliver" do
+#     let(:http) { described_class.new("MYKEY") }
+#     let(:buffer) { http.instance_variable_get(:@buffer) }
+
+#     after(:each) { http.close }
+
+#     it "should delivery properly and flush the buffer" do
+#       expect_any_instance_of(described_class).to receive(:at_exit).exactly(1).times.and_return(true)
+#       stub = stub_request(:post, "https://api.timber.io/http_frames").
+#         with(
+#           :body => "test log message",
+#           :headers => {'Authorization'=>'Basic TVlLRVk=', 'Connection'=>'keep-alive', 'Content-Type'=>'application/json', 'User-Agent'=>'Timber Ruby Gem/1.0.0'}
+#         ).
+#         to_return(:status => 200, :body => "", :headers => {})
+
+#       http.write("test log message")
+
+#       expect(buffer).to_not be_empty
+
+#       http.send(:deliver)
+
+#       expect(stub).to have_been_requested.times(1)
+#       expect(buffer).to be_empty
+#     end
+#   end
+# end

data/spec/timber/logger_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+describe Timber::Logger, :rails_23 => true do
+  describe "#add" do
+    let(:time) { Time.utc(2016, 9, 1, 12, 0, 0) }
+    let(:io) { StringIO.new }
+    let(:logger) { Timber::Logger.new(io) }
+
+    around(:each) do |example|
+      Timecop.freeze(time) { example.run }
+    end
+
+    context "with the :hybrid format" do
+      before(:each) { logger.formatter = Timber::Logger::HybridFormatter.new }
+
+      it "should accept strings" do
+        logger.info("this is a test")
+        expect(io.string).to eq("this is a test @timber.io {\"level\":\"info\",\"dt\":\"2016-09-01T12:00:00.000000Z\"}\n")
+      end
+
+      context "with a context" do
+        let(:http_context) do
+          Timber::Contexts::HTTP.new(
+            method: "POST",
+            path: "/checkout",
+            remote_addr: "123.456.789.10",
+            request_id: "abcd1234"
+          )
+        end
+
+        around(:each) do |example|
+          Timber::CurrentContext.instance.with(http_context) do
+            example.run
+          end
+        end
+
+        it "should snapshot and include the context" do
+          expect(Timber::CurrentContext.instance).to receive(:snapshot).and_call_original
+          logger.info("this is a test")
+          expect(io.string).to eq("this is a test @timber.io {\"level\":\"info\",\"dt\":\"2016-09-01T12:00:00.000000Z\",\"context\":{\"http\":{\"method\":\"POST\",\"path\":\"/checkout\",\"remote_addr\":\"123.456.789.10\",\"request_id\":\"abcd1234\"}}}\n")
+        end
+      end
+
+      it "should call and use Timber::Events.build" do
+        message = {message: "payment rejected", type: :payment_rejected, data: {customer_id: "abcde1234", amount: 100}}
+        expect(Timber::Events).to receive(:build).with(message).and_call_original
+        logger.info(message)
+        expect(io.string).to eq("payment rejected @timber.io {\"level\":\"info\",\"dt\":\"2016-09-01T12:00:00.000000Z\",\"event\":{\"custom\":{\"payment_rejected\":{\"customer_id\":\"abcde1234\",\"amount\":100}}}}\n")
+      end
+
+      it "should allow functions" do
+        logger.info do
+          {message: "payment rejected", type: :payment_rejected, data: {customer_id: "abcde1234", amount: 100}}
+        end
+        expect(io.string).to eq("payment rejected @timber.io {\"level\":\"info\",\"dt\":\"2016-09-01T12:00:00.000000Z\",\"event\":{\"custom\":{\"payment_rejected\":{\"customer_id\":\"abcde1234\",\"amount\":100}}}}\n")
+      end
+    end
+
+    context "with the :json format" do
+      before(:each) { logger.formatter = Timber::Logger::JSONFormatter.new }
+
+      it "should log in the correct format" do
+        logger.info("this is a test")
+        expect(io.string).to eq("{\"level\":\"info\",\"dt\":\"2016-09-01T12:00:00.000000Z\",\"message\":\"this is a test\"}\n")
+      end
+    end
+  end
+end

data/spec/timber/probes/action_controller_log_subscriber_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+
+describe Timber::Probes::ActionControllerLogSubscriber do
+  if defined?(described_class::LogSubscriber)
+    describe described_class::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
+
+      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
+
+        old_logger = ::ActionController::Base.logger
+        ::ActionController::Base.logger = logger
+
+        Timecop.freeze(time) { example.run }
+
+        Object.send(:remove_const, :LogSubscriberController)
+        ::ActionController::Base.logger = old_logger
+      end
+
+      describe "#start_processing, #process_action" do
+        it "should not log if the level is not sufficient" do
+          dispatch_rails_request("/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 the controller call event" 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")
+            message1 = <<-MSG
+              Processing by LogSubscriberController#index as HTML @timber.io {"level":"info","dt":"2016-09-01T12:00:00.000000Z","event":{"controller_call":{"controller":"LogSubscriberController","action":"index"}},"context":{"http":{"method":"GET","path":"/log_subscriber","remote_addr":"123.456.789.10","request_id":"unique-request-id-1234"}}}
+            MSG
+            message2 = <<-MSG
+              Completed 200 OK in 0.0ms (Views: 1.0ms) @timber.io {"level":"info","dt":"2016-09-01T12:00:00.000000Z","event":{"http_response":{"status":200,"time_ms":0.0}},"context":{"http":{"method":"GET","path":"/log_subscriber","remote_addr":"123.456.789.10","request_id":"unique-request-id-1234"}}}
+            MSG
+            expect(io.string).to eq(message1.strip + "\n" + message2.strip + "\n")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/timber/probes/action_dispatch_debug_exceptions_spec.rb

@@ -1,9 +1,17 @@
 require "spec_helper"
 
 describe Timber::Probes::ActionDispatchDebugExceptions do
-  describe described_class::InstanceMethods do
-    describe ".log_error" do
-      before(:each) do
+  describe "#{described_class}::*InstanceMethods" do
+    describe "#log_error" 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
+
+      around(:each) do |example|
         class ExceptionController < ActionController::Base
           layout nil
 
@@ -19,27 +27,25 @@ describe Timber::Probes::ActionDispatchDebugExceptions do
         ::RailsApp.routes.draw do
           get 'exception' => 'exception#index'
         end
-      end
 
-      after(:each) do
+        Timecop.freeze(time) { example.run }
+
         Object.send(:remove_const, :ExceptionController)
       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(:exception_context_class) { Timber::Contexts::Exception }
-
       it "should set the context" do
-        expect(Timber::CurrentContext).to receive(:add).with(kind_of(logger_context_class)).and_yield.at_least(:once)
-        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(exception_context_class)).and_yield
+        mock_class
         dispatch_rails_request("/exception")
+        # Because constantly updating the line numbers sucks :/
+        expect(io.string).to include("RuntimeError (boom):\n\n")
+        expect(io.string).to include("@timber.io")
+        expect(io.string).to include("\"event\":{\"exception\":{\"name\":\"RuntimeError\",\"message\":\"boom\",\"backtrace\":[\"")
+      end
+
+      def mock_class
+        klass = defined?(::ActionDispatch::DebugExceptions) ? ::ActionDispatch::DebugExceptions : ::ActionDispatch::ShowExceptions
+        allow_any_instance_of(klass).to receive(:logger).and_return(logger)
       end
     end
   end
-end
+end