timber 1.0.3

data/lib/timber/probes/action_dispatch_debug_exceptions.rb

@@ -0,0 +1,80 @@
+module Timber
+  module Probes
+    # Reponsible for automatically tracking exception events in Rails applications. While
+    # still preserving the default log style.
+    class ActionDispatchDebugExceptions < Probe
+      # For Rails >= 3.1
+      # @private
+      module DebugExceptionsInstanceMethods
+        def self.included(klass)
+          klass.class_eval do
+            private
+              def log_error(request, wrapper)
+                logger = logger(request)
+                return unless logger
+
+                exception = wrapper.exception
+
+                trace = wrapper.application_trace
+                trace = wrapper.framework_trace if trace.empty?
+
+                event = Events::Exception.new(
+                  name: exception.class.name,
+                  exception_message: exception.message,
+                  backtrace: trace
+                )
+
+                logger.fatal event
+              end
+          end
+        end
+      end
+
+      # For Rails < 3.1
+      # @private
+      module ShowExceptionsInstanceMethods #:nodoc:
+        def self.included(klass)
+          klass.class_eval do
+            private
+              # We have to monkey patch because ruby < 2.0 does not support prepend.
+              alias_method :_timber_old_log_error, :log_error
+
+              def log_error(exception)
+                return unless logger
+
+                event = Events::Exception.new(
+                  name: exception.class.name,
+                  exception_message: exception.message,
+                  backtrace: application_trace(exception)
+                )
+
+                logger.fatal event
+              end
+          end
+        end
+      end
+
+      def initialize
+        begin
+          # Rails >= 3.1
+          require "action_dispatch/middleware/debug_exceptions"
+        rescue LoadError
+          # Rails < 3.1
+          require "action_dispatch/middleware/show_exceptions"
+        end
+      rescue LoadError => e
+        raise RequirementNotMetError.new(e.message)
+      end
+
+      def insert!
+        if defined?(::ActionDispatch::DebugExceptions)
+          return true if ::ActionDispatch::DebugExceptions.include?(DebugExceptionsInstanceMethods)
+          ::ActionDispatch::DebugExceptions.send(:include, DebugExceptionsInstanceMethods)
+        else
+          return true if ::ActionDispatch::ShowExceptions.include?(ShowExceptionsInstanceMethods)
+          ::ActionDispatch::ShowExceptions.send(:include, ShowExceptionsInstanceMethods)
+        end
+      end
+    end
+  end
+end

data/lib/timber/probes/action_view_log_subscriber/log_subscriber.rb

@@ -0,0 +1,62 @@
+module Timber
+  module Probes
+    class ActionViewLogSubscriber < Probe
+      # The log subscriber that replaces the default `ActionView::LogSubscriber`.
+      # The intent of this subscriber is to, as transparently as possible, properly
+      # track events that are being logged here. This LogSubscriber will never change
+      # default behavior / log messages.
+      class LogSubscriber < ::ActionView::LogSubscriber
+        def render_template(event)
+          info do
+            full_name = from_rails_root(event.payload[:identifier])
+            message = "  Rendered #{full_name}"
+            message << " within #{from_rails_root(event.payload[:layout])}" if event.payload[:layout]
+            message << " (#{event.duration.round(1)}ms)"
+
+            Events::TemplateRender.new(
+              name: full_name,
+              time_ms: event.duration,
+              message: message
+            )
+          end
+        end
+
+        def render_partial(event)
+          info do
+            full_name = from_rails_root(event.payload[:identifier])
+            message = "  Rendered #{full_name}"
+            message << " within #{from_rails_root(event.payload[:layout])}" if event.payload[:layout]
+            message << " (#{event.duration.round(1)}ms)"
+            message << " #{cache_message(event.payload)}" if event.payload.key?(:cache_hit)
+
+            Events::TemplateRender.new(
+              name: full_name,
+              time_ms: event.duration,
+              message: message
+            )
+          end
+        end
+
+        def render_collection(event)
+          info do
+            identifier = event.payload[:identifier] || "templates"
+            full_name = from_rails_root(identifier)
+            message = "  Rendered collection of #{full_name}" \
+              " #{render_count(event.payload)} (#{event.duration.round(1)}ms)"
+
+            Events::TemplateRender.new(
+              name: full_name,
+              time_ms: event.duration,
+              message: message
+            )
+          end
+        end
+
+        private
+          def log_rendering_start(payload)
+            # Rails, you silly. We don't need to template rendering messages :)
+          end
+      end
+    end
+  end
+end

data/lib/timber/probes/action_view_log_subscriber.rb

@@ -0,0 +1,20 @@
+module Timber
+  module Probes
+    # Reponsible for automatically tracking template rendering events in `ActionView` while
+    # still preserving the default log style.
+    class ActionViewLogSubscriber < Probe
+      def initialize
+        require "action_view/log_subscriber"
+        require "timber/probes/action_view_log_subscriber/log_subscriber"
+      rescue LoadError => e
+        raise RequirementNotMetError.new(e.message)
+      end
+
+      def insert!
+        return true if Util::ActiveSupportLogSubscriber.subscribed?(:action_view, LogSubscriber)
+        Util::ActiveSupportLogSubscriber.unsubscribe(:action_view, ::ActionView::LogSubscriber)
+        LogSubscriber.attach_to(:action_view)
+      end
+    end
+  end
+end

data/lib/timber/probes/active_record_log_subscriber/log_subscriber.rb

@@ -0,0 +1,29 @@
+module Timber
+  module Probes
+    class ActiveRecordLogSubscriber < Probe
+      # The log subscriber that replaces the default `ActiveRecord::LogSubscriber`.
+      # The intent of this subscriber is to, as transparently as possible, properly
+      # track events that are being logged here. This LogSubscriber will never change
+      # default behavior / log messages.
+      class LogSubscriber < ::ActiveRecord::LogSubscriber #:nodoc:
+        def sql(event)
+          super(event)
+
+          payload = event.payload
+          event = Events::SQLQuery.new(
+            sql: payload[:sql],
+            time_ms: event.duration,
+            message: @message
+          )
+
+          logger.debug event
+        end
+
+        private
+          def debug(message)
+            @message = message
+          end
+      end
+    end
+  end
+end

data/lib/timber/probes/active_record_log_subscriber.rb

@@ -0,0 +1,20 @@
+module Timber
+  module Probes
+    # Reponsible for automatimcally tracking SQL query events in `ActiveRecord`, while still
+    # preserving the default log style.
+    class ActiveRecordLogSubscriber < Probe
+      def initialize
+        require "active_record/log_subscriber"
+        require "timber/probes/active_record_log_subscriber/log_subscriber"
+      rescue LoadError => e
+        raise RequirementNotMetError.new(e.message)
+      end
+
+      def insert!
+        return true if Util::ActiveSupportLogSubscriber.subscribed?(:active_record, LogSubscriber)
+        Util::ActiveSupportLogSubscriber.unsubscribe(:active_record, ::ActiveRecord::LogSubscriber)
+        LogSubscriber.attach_to(:active_record)
+      end
+    end
+  end
+end

data/lib/timber/probes/rack_http_context.rb

@@ -0,0 +1,51 @@
+module Timber
+  module Probes
+    # Reponsible for automatically adding the HTTP context for applications that use `Rack`.
+    class RackHTTPContext < Probe
+      class Middleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          request = ::Rack::Request.new(env)
+          context = Contexts::HTTP.new(
+            method: request.request_method,
+            path: request.path,
+            remote_addr: request.ip,
+            request_id: request_id(env)
+          )
+          CurrentContext.instance.with(context) do
+            @app.call(env)
+          end
+        end
+
+        private
+          def request_id(env)
+            env["X-Request-ID"] ||
+              env["X-Request-Id"] ||
+              env["action_dispatch.request_id"]
+          end
+      end
+
+      attr_reader :middleware, :insert_before
+
+      def initialize(middleware, insert_before)
+        if middleware.nil?
+          raise RequirementNotMetError.new("The middleware class attribute is not set. " +
+            "We need a middleware to insert the probe.")
+        end
+        @middleware = middleware
+        @insert_before = insert_before
+      end
+
+      def insert!
+        var_name = :"@_timber_rack_http_inserted"
+        return true if middleware.instance_variable_defined?(var_name) && middleware.instance_variable_get(var_name) == true
+        # Rails uses a proxy :/, so we need to do this instance variable hack
+        middleware.instance_variable_set(var_name, true)
+        middleware.insert_before insert_before, Middleware
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require "timber/probes/action_controller_log_subscriber"
+require "timber/probes/action_dispatch_debug_exceptions"
+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)
+      ActionControllerLogSubscriber.insert!
+      ActionDispatchDebugExceptions.insert!
+      ActionViewLogSubscriber.insert!
+      ActiveRecordLogSubscriber.insert!
+      RackHTTPContext.insert!(middleware, insert_before)
+      RailsRackLogger.insert!
+    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

@@ -0,0 +1,3 @@
+module Timber
+  VERSION = "1.0.3"
+end

data/lib/timber.rb

@@ -0,0 +1,22 @@
+# core classes
+require "json" # brings to_json to the core classes
+
+# Base (must come first, order matters)
+require "timber/config"
+require "timber/context"
+require "timber/event"
+require "timber/probe"
+require "timber/util"
+require "timber/version"
+
+# Other (sorted alphabetically)
+require "timber/contexts"
+require "timber/current_context"
+require "timber/events"
+require "timber/log_devices"
+require "timber/log_entry"
+require "timber/logger"
+require "timber/probes"
+
+# Load frameworks
+require "timber/frameworks"

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+# Base
+require 'rubygems'
+require 'bundler/setup'
+
+# Testing
+require 'pry'
+require 'rspec'
+require 'rspec/its'
+require 'rspec/mocks'
+
+# Support files, order is relevant
+require File.join(File.dirname(__FILE__), 'support', 'coveralls')
+require File.join(File.dirname(__FILE__), 'support', 'socket_hostname')
+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')
+
+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
+  config.order = :random
+  config.warnings = false
+end

data/spec/support/action_controller.rb

@@ -0,0 +1,4 @@
+require "action_controller"
+
+ActionController::Base.prepend_view_path("#{File.dirname(__FILE__)}/rails/templates")
+ActionController::Base.logger = Rails.logger

data/spec/support/action_view.rb

@@ -0,0 +1,4 @@
+require "action_view"
+
+# Needed for the ActionView::LogSubscriber. If a logger is not present, nothing will be logged.
+ActionView::Base.logger = Rails.logger if ActionView::Base.respond_to?(:logger=)

data/spec/support/active_record.rb

@@ -0,0 +1,28 @@
+require 'active_record'
+
+ActiveRecord::Base.logger = Rails.logger
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :organizations, :force => true do |t|
+    t.string :name
+
+    t.timestamps :null => false
+  end
+
+  create_table :users, :force => true do |t|
+    t.integer :age
+    t.string :email
+    t.string :first_name
+
+    t.timestamps :null => false
+  end
+
+end
+
+class Organization < ::ActiveRecord::Base
+end
+
+class User < ::ActiveRecord::Base
+end

data/spec/support/coveralls.rb

@@ -0,0 +1,2 @@
+require 'coveralls'
+Coveralls.wear!

data/spec/support/rails/templates/_partial.html

@@ -0,0 +1 @@
+I am a partial

data/spec/support/rails/templates/template.html

@@ -0,0 +1 @@
+I am a template

data/spec/support/rails.rb

@@ -0,0 +1,37 @@
+require "rails"
+
+# 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\./
+    config.secret_token = '1e05af2b349457936a41427e63450937'
+  else
+    config.secret_key_base = '1e05af2b349457936a41427e63450937'
+  end
+  config.active_support.deprecation = :stderr
+  config.eager_load = false
+end
+
+RailsApp.initialize!
+
+module Support
+  module Rails
+    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
+end
+
+RSpec.configure do |config|
+  config.include Support::Rails
+end

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,4 @@
+# Must require last in order to be mocked via webmock
+require 'timber'
+
+Timber::Config.instance.logger = ::Logger.new(nil)

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/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