timberio 1.0.0.beta1

data/lib/timber/macros/logfmt_encoder.rb

@@ -0,0 +1,77 @@
+module Timber
+  module Macros
+    # Encodes a hash into a simple logfmt string.
+    #
+    # A couple of important points:
+    #
+    # 1. This module is designed to be fast, as it is executed inline with
+    #    each log line.
+    # 2. It makes assumptions about the hash structure, and is designed
+    #    specifically for Timber. We can reduce the edge cases and improve
+    #    performance drastically.
+    class LogfmtEncoder
+      ARRAY_DELIMITER = ",".freeze
+      ARRAY_END = "]".freeze
+      ARRAY_START = "[".freeze
+      ESCAPE = "\\".freeze
+      KEY_DELIMITER = ".".freeze
+      KEY_VALUE_DELIMITER = "=".freeze
+      PAIR_DELIMITER = " ".freeze
+      STRING_WRAPPER = "\"".freeze
+      SPECIAL_KEY_CHARACTERS = [KEY_DELIMITER, PAIR_DELIMITER].freeze
+      SPECIAL_VALUE_CHARACTERS = [ARRAY_DELIMITER, ARRAY_END, ARRAY_START, ESCAPE, PAIR_DELIMITER, STRING_WRAPPER].freeze
+
+      def self.encode(hash, ancestors = [])
+        if !hash.is_a?(Hash)
+          raise ArgumentError.new("hash must be a Hash")
+        end
+        items = hash.collect do |key, value|
+          keys = ancestors + [key]
+          if value.is_a?(Hash)
+            encode(value, keys)
+          else
+            "#{encode_keys(keys)}#{KEY_VALUE_DELIMITER}#{encode_value(value)}"
+          end
+        end.flatten
+        join(*items)
+      end
+
+      def self.join(*items)
+        items.join(PAIR_DELIMITER)
+      end
+
+      private
+        def self.encode_keys(keys)
+          keys.collect { |key| encode_key(key) }.join(KEY_DELIMITER)
+        end
+
+        def self.encode_key(key)
+          key = key.to_s
+          if SPECIAL_KEY_CHARACTERS.any? { |c| key.include?(c) }
+            escape(key)
+          else
+            key
+          end
+        end
+
+        def self.encode_value(value)
+          if value.is_a?(Array)
+            values = value.collect { |v| encode_value(v) }.join(ARRAY_DELIMITER)
+            "#{ARRAY_START}#{values}#{ARRAY_END}"
+          elsif value.is_a?(String) && SPECIAL_VALUE_CHARACTERS.any? { |c| value.include?(c) }
+            escape(value)
+          else
+            value
+          end
+        end
+
+        def self.escape(value)
+          # Simple gsub that is better for performance, we do not need to handle
+          # all of the edgecases that to_json handled. #to_json is also much slower.
+          new_value = value.gsub(STRING_WRAPPER, "#{ESCAPE}#{STRING_WRAPPER}")
+          new_value.gsub!(ESCAPE, "#{ESCAPE}#{ESCAPE}")
+          "#{STRING_WRAPPER}#{new_value}#{STRING_WRAPPER}"
+        end
+    end
+  end
+end

data/lib/timber/macros.rb

@@ -0,0 +1,4 @@
+require "timber/macros/compactor"
+require "timber/macros/date_formatter"
+require "timber/macros/deep_merger"
+require "timber/macros/logfmt_encoder"

data/lib/timber/patterns/delegated_singleton.rb

@@ -0,0 +1,21 @@
+require "singleton"
+
+module Timber
+  module Patterns
+    module DelegatedSingleton
+      def self.included(klass)
+        klass.class_eval do
+          extend ClassMethods
+          include Singleton
+        end
+      end
+
+      module ClassMethods
+        private
+          def method_missing(name, *args, &block)
+            instance.send(name, *args, &block)
+          end
+      end
+    end
+  end
+end

data/lib/timber/patterns/to_json.rb

@@ -0,0 +1,22 @@
+module Timber
+  module Patterns
+    # Module to fall inline with Rail's core object crazy changes.
+    # If Rails is present, it will play nice. If not, it will work just fine.
+    module ToJSON
+      # We explicitly do not do anything with the arguments as we do not need them.
+      # We avoid the unneccssary complexity.
+      def as_json(*_args)
+        @as_json ||= Macros::Compactor.compact(json_payload).freeze
+      end
+
+      def to_json(*_args)
+        @to_json ||= as_json.to_json.freeze
+      end
+
+      private
+        def json_payload
+          raise NotImplementedError.new("#json_payload is not implemented for #{self.class}")
+        end
+    end
+  end
+end

data/lib/timber/patterns/to_logfmt.rb

@@ -0,0 +1,9 @@
+module Timber
+  module Patterns
+    module ToLogfmt
+      def to_logfmt
+        @to_logfmt ||= Macros::LogfmtEncoder.encode(as_json).freeze
+      end
+    end
+  end
+end

data/lib/timber/patterns.rb

@@ -0,0 +1,3 @@
+require "timber/patterns/delegated_singleton"
+require "timber/patterns/to_json"
+require "timber/patterns/to_logfmt"

data/lib/timber/probe.rb

@@ -0,0 +1,21 @@
+module Timber
+  class Probe
+    class RequirementNotMetError < StandardError; end
+
+    class << self
+      def insert!(*args)
+        new(*args).insert!
+        Config.logger.debug("Inserted probe #{name}")
+        true
+      # RequirementUnsatisfiedError is the only silent failure we support
+      rescue RequirementNotMetError => e
+        Config.logger.debug("Failed inserting probe #{name}: #{e.message}")
+        false
+      end
+    end
+
+    def insert!
+      raise NotImplementedError.new("You must implement #insert")
+    end
+  end
+end

data/lib/timber/probes/action_controller_base.rb

@@ -0,0 +1,31 @@
+module Timber
+  module Probes
+    # Wraps process_action so that we get *anu* logs written within the controller.
+    # This is superior to using process_action in ActionController::LogSubscriber.
+    class ActionControllerBase < Probe
+      module InstanceMethods
+        def process(*args)
+          request_context      = Contexts::HTTPRequests::ActionControllerSpecific.new(self)
+          organization_context = Contexts::Organizations::ActionController.new(self)
+          user_context         = Contexts::Users::ActionController.new(self)
+          response_context     = Contexts::HTTPResponses::ActionController.new(self)
+          # The order is relevant here, request_context is higher in the hierarchy
+          CurrentContext.add(request_context, organization_context, user_context, response_context) do
+            super
+          end
+        end
+      end
+
+      def initialize
+        require "action_controller"
+      rescue LoadError => e
+        raise RequirementNotMetError.new(e.message)
+      end
+
+      def insert!
+        return true if ::ActionController::Base.include?(InstanceMethods)
+        ::ActionController::Base.send(:include, InstanceMethods)
+      end
+    end
+  end
+end

data/lib/timber/probes/action_dispatch_debug_exceptions.rb

@@ -0,0 +1,57 @@
+module Timber
+  module Probes
+    class ActionDispatchDebugExceptions < Probe
+      module InstanceMethods
+        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(*args)
+                # Rails 3.0 has 1 arg, >= 3.1 uses 2 args, the last being an exception wrapper
+                exception = args.size == 1 ? args.first : args.last.exception
+                # AR only logs queries if debugging, no need to do anything otherwise
+                context = Contexts::Exception.new(exception)
+                CurrentContext.add(context) do
+                  _timber_old_log_error(*args)
+                end
+              end
+          end
+        end
+      end
+
+      attr_reader :target_class
+
+      def initialize
+        load_debug_exceptions
+      rescue RequirementNotMetError
+        load_show_exceptions
+      end
+
+      def insert!
+        return true if target_class.include?(InstanceMethods)
+        target_class.send(:include, InstanceMethods)
+      end
+
+      private
+        # Rails >= 3.1 logs the error here
+        def load_debug_exceptions
+          require "action_dispatch/middleware/debug_exceptions"
+          @target_class = ::ActionDispatch::DebugExceptions
+          true
+        rescue LoadError => e
+          raise RequirementNotMetError.new(e.message)
+        end
+
+        # Rails 3.0 logs the error here
+        def load_show_exceptions
+          require "action_dispatch/middleware/show_exceptions"
+          @target_class = ::ActionDispatch::ShowExceptions
+          true
+        rescue LoadError => e
+          raise RequirementNotMetError.new(e.message)
+        end
+    end
+  end
+end

data/lib/timber/probes/active_support_log_subscriber/action_controller.rb

@@ -0,0 +1,15 @@
+module Timber
+  module Probes
+    class ActiveSupportLogSubscriber < Probe
+      module ActionController
+        def self.process_action(_log_subscriber, event, &_block)
+          context = CurrentContext.get(Contexts::HTTPResponses::ActionController)
+          if context
+            context.event = event
+          end
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/timber/probes/active_support_log_subscriber/action_view.rb

@@ -0,0 +1,26 @@
+module Timber
+  module Probes
+    class ActiveSupportLogSubscriber < Probe
+      class ActionView
+        def self.render_collection(_log_subscriber, event, &_block)
+          wrap(event) { yield }
+        end
+
+        def self.render_partial(_log_subscriber, event, &_block)
+          wrap(event) { yield }
+        end
+
+        def self.render_template(_log_subscriber, event, &_block)
+          wrap(event) { yield }
+        end
+
+        private
+          def self.wrap(event, &_block)
+            context1 = Contexts::TemplateRenders::ActionView.new(event)
+            context2 = Contexts::TemplateRenders::ActionViewSpecific.new(event)
+            CurrentContext.add(context1, context2) { yield }
+          end
+      end
+    end
+  end
+end

data/lib/timber/probes/active_support_log_subscriber/active_record.rb

@@ -0,0 +1,13 @@
+module Timber
+  module Probes
+    class ActiveSupportLogSubscriber < Probe
+      module ActiveRecord
+        def self.sql(log_subscriber, event, &_block)
+          context1 = Contexts::SQLQueries::ActiveRecord.new(log_subscriber, event)
+          context2 = Contexts::SQLQueries::ActiveRecordSpecific.new(log_subscriber, event)
+          CurrentContext.add(context1, context2) { yield }
+        end
+      end
+    end
+  end
+end

data/lib/timber/probes/active_support_log_subscriber.rb

@@ -0,0 +1,62 @@
+require "timber/probes/active_support_log_subscriber/action_controller"
+require "timber/probes/active_support_log_subscriber/action_view"
+require "timber/probes/active_support_log_subscriber/active_record"
+
+module Timber
+  module Probes
+    # We want to wrap every log subscriber. Think about something like
+    # lograge. We want to add context to those logs as well, not just
+    # the internal rails log subscribers.
+    class ActiveSupportLogSubscriber < Probe
+      module ClassMethods
+        def self.included(klass)
+          klass.class_eval do
+            alias_method :_timber_old_send, :send
+
+            # Override send since the #finish method uses that to send the event.
+            # This allows us to wrap the actual method.
+            def send(method_name, *args, &block)
+              if args.first.is_a?(ActiveSupport::Notifications::Event)
+                ActiveSupportLogSubscriber.wrap(self, args.first) do
+                  _timber_old_send(method_name, *args, &block)
+                end
+              else
+                _timber_old_send(method_name, *args, &block)
+              end
+            end
+          end
+        end
+      end
+
+      class << self
+        WRAPPER_MAP = {
+          "action_controller" => ActionController,
+          "action_view"       => ActionView,
+          "active_record"     => ActiveRecord
+        }.freeze
+        EVENT_DELIMITER = ".".freeze
+
+        def wrap(log_subscriber, event, &_block)
+          event_name, namespace = event.name.split(EVENT_DELIMITER)
+          wrapper = WRAPPER_MAP[namespace]
+          if wrapper && wrapper.respond_to?(event_name)
+            wrapper.send(event_name, log_subscriber, event) { yield }
+          else
+            yield
+          end
+        end
+      end
+
+      def initialize
+        require "active_support/log_subscriber"
+      rescue LoadError => e
+        raise RequirementNotMetError.new(e.message)
+      end
+
+      def insert!
+        return true if ::ActiveSupport::LogSubscriber.include?(ClassMethods)
+        ::ActiveSupport::LogSubscriber.send(:include, ClassMethods)
+      end
+    end
+  end
+end

data/lib/timber/probes/heroku.rb

@@ -0,0 +1,30 @@
+module Timber
+  module Probes
+    class Heroku < Probe
+      class << self
+        attr_accessor :inserted
+      end
+
+      def initialize
+        if dyno.nil?
+          raise RequirementNotMetError.new("The DYNO environment variable is not set. " +
+            "Not in the Heroku environment.")
+        end
+      end
+
+      def insert!
+        return true if self.class.inserted == true
+        context = Contexts::Servers::HerokuSpecific.new(dyno)
+        # Note we don't use a block here, this is because
+        # the context is persistent.
+        CurrentContext.add(context)
+        self.class.inserted = true
+      end
+
+      private
+        def dyno
+          ENV['DYNO']
+        end
+    end
+  end
+end

data/lib/timber/probes/logger.rb

@@ -0,0 +1,31 @@
+require "logger"
+
+module Timber
+  module Probes
+    class Logger < Probe
+      module InstanceMethods
+        def self.included(klass)
+          klass.class_eval do
+            alias_method :_timber_old_add, :add
+
+            def add(level, *args, &block)
+              if self == Config.logger
+                _timber_old_add(level, *args, &block)
+              else
+                context = Contexts::Logger.new(level, progname)
+                CurrentContext.add(context) do
+                  _timber_old_add(level, *args, &block)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def insert!
+        return true if ::Logger.include?(InstanceMethods)
+        ::Logger.send(:include, InstanceMethods)
+      end
+    end
+  end
+end

data/lib/timber/probes/rack.rb

@@ -0,0 +1,36 @@
+module Timber
+  module Probes
+    class Rack < Probe
+      class Middleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          context = Contexts::HTTPRequests::Rack.new(env)
+          CurrentContext.add(context) do
+            @app.call(env)
+          end
+        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!
+        return true if middleware.instance_variable_get(:"@_timber_inserted") == true
+        # Rails uses a proxy :/
+        middleware.instance_variable_set(:"@_timber_inserted", true)
+        middleware.insert_before insert_before, Middleware
+      end
+    end
+  end
+end

data/lib/timber/probes/server.rb

@@ -0,0 +1,18 @@
+module Timber
+  module Probes
+    class Server < Probe
+      class << self
+        attr_accessor :inserted
+      end
+
+      def insert!
+        return true if self.class.inserted == true
+        context = Contexts::Server.new
+        # Note we don't use a block here, this is because
+        # the context is persistent.
+        CurrentContext.add(context)
+        self.class.inserted = true
+      end
+    end
+  end
+end

data/lib/timber/probes.rb

@@ -0,0 +1,24 @@
+require "timber/probes/action_controller_base"
+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"
+
+module Timber
+  module Probes
+    def self.insert!(middleware, insert_before)
+      # Persistent probes. Order is relevant.
+      Server.insert!
+      Heroku.insert!
+
+      # Transient probes, sorted alphabetically
+      ActionControllerBase.insert!
+      ActionDispatchDebugExceptions.insert!
+      ActiveSupportLogSubscriber.insert!
+      Logger.insert!
+      Rack.insert!(middleware, insert_before)
+    end
+  end
+end

data/lib/timber/version.rb

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

data/lib/timber.rb

@@ -0,0 +1,27 @@
+# core classes
+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/probe"
+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/log_devices"
+require "timber/log_line"
+require "timber/logger"
+require "timber/probes"
+
+# Load frameworks last
+require "timber/frameworks"

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+# 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')
+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')
+
+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,33 @@
+require "rails"
+
+log_dev = Timber::LogDevices::IO.new
+Rails.logger = Timber::Logger.new(log_dev)
+Rails.logger.level = ::Logger::FATAL
+
+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
+  config.log_level = :fatal
+end
+
+RailsApp.initialize!
+
+module Support
+  module Rails
+    def dispatch_rails_request(path)
+      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
+      ::Rack::MockRequest.new(application).get(path, env)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Support::Rails
+end