timberio 1.0.0.beta1

data/lib/timber/contexts/organizations/action_controller.rb

@@ -0,0 +1,34 @@
+module Timber
+  module Contexts
+    module Organizations
+      class ActionController < Organization
+        DEFAULT_METHOD_NAME = :current_organization.freeze
+
+        class << self
+          attr_writer :method_name
+
+          def method_name
+            @method_name ||= DEFAULT_METHOD_NAME
+          end
+        end
+
+        attr_reader :controller
+
+        def initialize(controller)
+          @controller = controller
+          super()
+        end
+
+        private
+          def method_name
+            self.class.method_name
+          end
+
+          def organization
+            return @organization if defined?(@organization)
+            @organization = controller.respond_to?(method_name, true) ? controller.send(method_name) : nil
+          end
+      end
+    end
+  end
+end

data/lib/timber/contexts/server.rb

@@ -0,0 +1,21 @@
+require "socket"
+
+module Timber
+  module Contexts
+    class Server < Context
+      ROOT_KEY = :server.freeze
+      VERSION = 1.freeze
+
+      def hostname
+        @hostname ||= ::Socket.gethostname
+      end
+
+      private
+        def json_payload
+          @json_payload ||= Macros::DeepMerger.merge({
+            :hostname => hostname
+          }, super).freeze
+        end
+    end
+  end
+end

data/lib/timber/contexts/servers/heroku_specific.rb

@@ -0,0 +1,48 @@
+module Timber
+  module Contexts
+    module Servers
+      # Because this is a sub context we do not extend Server.
+      class HerokuSpecific < Context
+        ROOT_KEY = :heroku.freeze
+        VERSION = 1.freeze
+        DELIMITER = ".".freeze
+
+        class << self
+          def json_shell(&_block)
+            Server.json_shell { super }
+          end
+        end
+
+        attr_reader :dyno
+
+        def initialize(dyno)
+          # Initialize should be as fast as possible since it is executed inline.
+          # Hence the lazy methods below.
+          @dyno = dyno
+          super()
+        end
+
+        def process_type
+          @process_type ||= parts.first
+        end
+
+        def dyno_id
+          @dyno_id ||= parts.last
+        end
+
+        private
+          def parts
+            @parts ||= dyno.split(DELIMITER)
+          end
+
+          def json_payload
+            @json_payload ||= Macros::DeepMerger.merge({
+              # order is relevant for logfmt styling
+              :process_type => process_type,
+              :dyno_id => dyno_id
+            }, super).freeze.freeze
+          end
+      end
+    end
+  end
+end

data/lib/timber/contexts/sql_queries/active_record.rb

@@ -0,0 +1,30 @@
+module Timber
+  module Contexts
+    module SQLQueries
+      class ActiveRecord < SQLQuery
+        attr_reader :log_subscriber, :event
+
+        def initialize(log_subscriber, event)
+          # Initialize should be as fast as possible since it is executed inline.
+          # Hence the lazy methods below.
+          @log_subscriber = log_subscriber
+          @event = event
+          super()
+        end
+
+        def sql
+          @sql ||= payload[:sql].try(:strip)
+        end
+
+        def time_ms
+          @time_ms ||= event.duration
+        end
+
+        private
+          def payload
+            event.payload
+          end
+      end
+    end
+  end
+end

data/lib/timber/contexts/sql_queries/active_record_specific/binds.rb

@@ -0,0 +1,37 @@
+module Timber
+  module Contexts
+    module SQLQueries
+      class ActiveRecordSpecific < Context
+        class Binds < DynamicValues
+          attr_reader :log_subscriber, :binds
+
+          def initialize(log_subscriber, binds)
+            # Initialize should be as fast as possible since it is executed inline.
+            # Hence the lazy methods below.
+            @log_subscriber = log_subscriber
+            @binds = binds
+            super()
+          end
+
+          private
+            # Override values_array so that this is done in the background thread
+            def values_array
+              @values_array ||= binds.collect do |bind|
+                name, value = render_bind(bind)
+                {:name => name, :value => value}
+              end
+            end
+
+            def render_bind(bind)
+              if bind.is_a?(Array)
+                # AR 4.2.X
+                log_subscriber.render_bind(*bind)
+              else
+                log_subscriber.render_bind(bind)
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/timber/contexts/sql_queries/active_record_specific.rb

@@ -0,0 +1,59 @@
+require "timber/contexts/sql_queries/active_record_specific/binds"
+
+module Timber
+  module Contexts
+    module SQLQueries
+      # Because this is a sub context we extend Context
+      class ActiveRecordSpecific < Context
+        ROOT_KEY = :active_record.freeze
+        VERSION = 1.freeze
+
+        class << self
+          def json_shell(&_block)
+            SQLQuery.json_shell { super }
+          end
+        end
+
+        attr_reader :log_subscriber, :event
+
+        def initialize(log_subscriber, event)
+          # Initialize should be as fast as possible since it is executed inline.
+          # Hence the lazy methods below.
+          @log_subscriber = log_subscriber
+          @event = event
+          super()
+        end
+
+        def binds
+          @binds ||= payload[:binds] && Binds.new(log_subscriber, payload[:binds])
+        end
+
+        def connection_id
+          @connection_id ||= payload[:connection_id].try(:to_s)
+        end
+
+        def statement_name
+          @statement_name ||= payload[:statement_name]
+        end
+
+        def transaction_id
+          @transaction_id ||= event.transaction_id.try(:to_s)
+        end
+
+        private
+          def json_payload
+            @json_payload ||= Macros::DeepMerger.merge({
+              :binds => binds.as_json,
+              :connection_id => connection_id,
+              :statement_name => statement_name,
+              :transaction_id => transaction_id
+            }, super).freeze
+          end
+
+          def payload
+            event.payload
+          end
+      end
+    end
+  end
+end

data/lib/timber/contexts/sql_query.rb

@@ -0,0 +1,18 @@
+module Timber
+  module Contexts
+    # Base class for SQLQuery sub types.
+    class SQLQuery < Context
+      ROOT_KEY = :sql_query.freeze
+      VERSION = 1.freeze
+
+      private
+        def json_payload
+          @json_payload ||= Macros::DeepMerger.merge({
+            # order is relevant for logfmt styling
+            :sql => sql,
+            :time_ms => time_ms
+          }, super).freeze
+        end
+    end
+  end
+end

data/lib/timber/contexts/template_render.rb

@@ -0,0 +1,17 @@
+module Timber
+  module Contexts
+    class TemplateRender < Context
+      ROOT_KEY = :template_render.freeze
+      VERSION = 1.freeze
+
+      private
+        def json_payload
+          @json_payload ||= Macros::DeepMerger.merge({
+            # order is relevant for logfmt styling
+            :name => name,
+            :time_ms => time_ms
+          }, super).freeze
+        end
+    end
+  end
+end

data/lib/timber/contexts/template_renders/action_view.rb

@@ -0,0 +1,29 @@
+module Timber
+  module Contexts
+    module TemplateRenders
+      class ActionView < TemplateRender
+        attr_reader :event
+
+        def initialize(event)
+          # Initialize should be as fast as possible since it is executed inline.
+          # Hence the lazy methods below.
+          @event = event
+          super()
+        end
+
+        def name
+          @name ||= payload[:identifier]
+        end
+
+        def time_ms
+          @time_ms ||= event.duration
+        end
+
+        private
+          def payload
+            event.payload
+          end
+      end
+    end
+  end
+end

data/lib/timber/contexts/template_renders/action_view_specific.rb

@@ -0,0 +1,51 @@
+module Timber
+  module Contexts
+    module TemplateRenders
+      # Because this is a sub type we extend Context
+      class ActionViewSpecific < Context
+        ROOT_KEY = :action_view.freeze
+        VERSION = 1.freeze
+
+        class << self
+          def json_shell(&_block)
+            TemplateRender.json_shell { super }
+          end
+        end
+
+        attr_reader :event
+
+        def initialize(event)
+          # Initialize should be as fast as possible since it is executed inline.
+          # Hence the lazy methods below.
+          @event = event
+          super()
+        end
+
+        def cache_hits
+          @cache_hits ||= payload[:cache_hits]
+        end
+
+        def count
+          @count ||= payload[:count]
+        end
+
+        def layout
+          @layout ||= payload[:layout]
+        end
+
+        private
+          def json_payload
+            @json_payload ||= Macros::DeepMerger.merge({
+              :cache_hits => cache_hits,
+              :count => count,
+              :layout => layout
+            }, super).freeze
+          end
+
+          def payload
+            event.payload
+          end
+      end
+    end
+  end
+end

data/lib/timber/contexts/user.rb

@@ -0,0 +1,39 @@
+module Timber
+  module Contexts
+    class User < Context
+      ROOT_KEY = :user.freeze
+      VERSION = 1.freeze
+
+      attr_reader :user
+
+      def email
+        return @email if defined?(@email)
+        @email = user.respond_to?(:email) ? user.email : nil
+      end
+
+      def id
+        return @id if defined?(@id)
+        @id = user.respond_to?(:id) ? user.id : nil
+      end
+
+      def name
+        return @name if defined?(@name)
+        @name = user.respond_to?(:name) ? user.name : nil
+      end
+
+      def valid?
+        !user.nil?
+      end
+
+      private
+        def json_payload
+          @json_payload ||= Macros::DeepMerger.merge({
+            # order is relevant for logfmt styling
+            :id => id,
+            :name => name,
+            :email => email
+          }, super).freeze
+        end
+    end
+  end
+end

data/lib/timber/contexts/users/action_controller.rb

@@ -0,0 +1,34 @@
+module Timber
+  module Contexts
+    module Users
+      class ActionController < User
+        DEFAULT_METHOD_NAME = :current_user.freeze
+
+        class << self
+          attr_writer :method_name
+
+          def method_name
+            @method_name ||= DEFAULT_METHOD_NAME
+          end
+        end
+
+        attr_reader :controller
+
+        def initialize(controller)
+          @controller = controller
+          super()
+        end
+
+        private
+          def method_name
+            self.class.method_name
+          end
+
+          def user
+            return @user if defined?(@user)
+            @user = controller.respond_to?(method_name, true) ? controller.send(method_name) : nil
+          end
+      end
+    end
+  end
+end

data/lib/timber/contexts.rb

@@ -0,0 +1,23 @@
+# Base, order is relevant
+require "timber/contexts/dynamic_values"
+require "timber/contexts/exception"
+require "timber/contexts/http_request"
+require "timber/contexts/http_response"
+require "timber/contexts/logger"
+require "timber/contexts/organization"
+require "timber/contexts/server"
+require "timber/contexts/sql_query"
+require "timber/contexts/template_render"
+require "timber/contexts/user"
+
+# Sub contexts, order is relevant
+require "timber/contexts/http_requests/rack"
+require "timber/contexts/http_requests/action_controller_specific"
+require "timber/contexts/http_responses/action_controller"
+require "timber/contexts/organizations/action_controller"
+require "timber/contexts/servers/heroku_specific"
+require "timber/contexts/sql_queries/active_record"
+require "timber/contexts/sql_queries/active_record_specific"
+require "timber/contexts/template_renders/action_view"
+require "timber/contexts/template_renders/action_view_specific"
+require "timber/contexts/users/action_controller"

data/lib/timber/current_context.rb

@@ -0,0 +1,58 @@
+require "set"
+
+module Timber
+  # Holds the current context in the current thread's memory.
+  # This context gets copied as each log line is written.
+  class CurrentContext
+    THREAD_NAMESPACE = :_timber_current_context.freeze
+    STACK_KEYNAME = :stack.freeze
+    PRECISION = 8.freeze
+
+    include Patterns::DelegatedSingleton
+
+    # Adds a context to the current stack.
+    def add(*contexts, &_block)
+      contexts = contexts.compact
+      contexts.each do |context|
+        stack << context
+      end
+      block_given? ? yield : self
+    ensure
+      remove(*contexts) if block_given?
+    end
+
+    # Get a specific context type off the stack
+    def get(type)
+      stack.find { |context| context.is_a?(type) }
+    end
+
+    # Removes the contexts from the current stack.
+    def remove(*contexts)
+      # Ensure we clear the cacke when the stack changes
+      contexts.each do |context|
+        CurrentLineIndexes.context_removed(context)
+        stack.delete(context)
+      end
+      self
+    end
+
+    # Used to efficiently clone the context
+    def snapshot
+      # Cloning the array is efficient and will point to the same objects.
+      Timber::ContextSnapshot.new
+    end
+
+    def valid_stack
+      stack.select(&:valid?)
+    end
+
+    private
+      def stack
+        storage[STACK_KEYNAME] ||= []
+      end
+
+      def storage
+        Thread.current[THREAD_NAMESPACE] ||= {}
+      end
+  end
+end

data/lib/timber/current_line_indexes.rb

@@ -0,0 +1,35 @@
+module Timber
+  # Holds the log line counts on a per context basis in memory.
+  class CurrentLineIndexes
+    THREAD_NAMESPACE = :_timber_current_line_counts.freeze
+
+    include Patterns::DelegatedSingleton
+
+    def context_removed(context)
+      indexes.delete(context)
+    end
+
+    def indexes
+      Thread.current[THREAD_NAMESPACE] ||= {}
+    end
+
+    def log_line_added(_log_line)
+      CurrentContext.valid_stack.each do |context|
+        if indexes.key?(context)
+          indexes[context] += 1
+        else
+          indexes[context] = 0
+        end
+      end
+    end
+
+    def reset!
+      indexes.clear
+    end
+
+    def snapshot
+      # No need to cache, this is blown out for each log line
+      LineIndexesSnapshot.new(self)
+    end
+  end
+end

data/lib/timber/frameworks/rails.rb

@@ -0,0 +1,24 @@
+module Timber
+  module Frameworks
+    module Rails
+      class Railtie < ::Rails::Railtie
+        config.timber = Config.instance
+        config.before_initialize do
+          Bootstrap.bootstrap!(config.app_middleware, ::Rails::Rack::Logger)
+        end
+      end
+
+      def self.base_logger(logdev)
+        defined?(::ActiveSupport::Logger) ?
+          ::ActiveSupport::Logger.new(logdev) :
+          ::Logger.new(logdev)
+      end
+
+      def self.logger(logdev)
+        defined?(::ActiveSupport::TaggedLogging) ?
+          ::ActiveSupport::TaggedLogging.new(base_logger(logdev)) :
+          base_logger(logdev)
+      end
+    end
+  end
+end

data/lib/timber/frameworks.rb

@@ -0,0 +1,21 @@
+require "logger"
+
+# Attempt to require Rails. We can not list it as a gem
+# dependency because we want to support multiple frameworks.
+require("rails") rescue LoadError
+
+if defined?(Rails)
+  require 'timber/frameworks/rails'
+end
+
+module Timber
+  module Frameworks
+    def self.logger(logdev)
+      if defined?(Timber::Frameworks::Rails)
+        Rails.logger(logdev)
+      else
+        ::Logger.new(logdev)
+      end
+    end
+  end
+end

data/lib/timber/internal_logger.rb

@@ -0,0 +1,35 @@
+require "logger"
+
+module Timber
+  # Allows us to prefix all logs with [Timber] without having to
+  # rely on external dependencies. This is slightly different
+  # in that we don't want to create an entirely new logger or modify
+  # the logger they pass us. We only want to prefix logs in the context
+  # of this library.
+  class InternalLogger < ::Logger
+    class Formatter < ::Logger::Formatter
+      TAG = "[Timber]"
+
+      # This method is invoked when a log event occurs
+      def call(_severity, _timestamp, _progname, msg)
+        "#{TAG} #{String === msg ? msg : msg.inspect}\n"
+      end
+    end
+
+    def initialize(*args)
+      super
+      @formatter = Formatter.new
+    end
+
+    # This is a convenience method for logging exceptions. Also
+    # allows us to build a notify hook for any exception that happen in
+    # the Timber library. This is extremely important for quality control.
+    def exception(exception)
+      if !exception.is_a?(Exception)
+        raise ArgumentError.new("#exception must take an Exception type")
+      end
+      # TODO: notify us that this exception happened
+      error("#{exception.inspect}: #{exception.backtrace.inspect}")
+    end
+  end
+end

data/lib/timber/log_device.rb

@@ -0,0 +1,40 @@
+module Timber
+  class LogDevice
+    NEWLINE = "\n".freeze
+    SPLIT_LINES = true
+
+    def write(message)
+      return false if ignoring?
+      ignore do
+        messages(message).each do |message_part|
+          log_line = LogLine.new(message_part)
+          write_log_line(log_line)
+        end
+      end
+      true
+    rescue Exception => e
+      Config.logger.exception(e)
+      raise e
+    end
+
+    private
+      def ignore(&block)
+        @ignoring = true
+        yield
+      ensure
+        @ignoring = false
+      end
+
+      def ignoring?
+        @ignoring == true
+      end
+
+      def messages(message)
+        message.chomp.split(NEWLINE)
+      end
+
+      def write_formatted(formatted_message)
+        raise NotImplementedError.new
+      end
+    end
+end

data/lib/timber/log_devices/heroku_logplex/hybrid_formatter.rb

@@ -0,0 +1,14 @@
+module Timber
+  module LogDevices
+    class HerokuLogplex < IO
+      module HybridFormatter
+        private
+          def encoded_context(log_line)
+            log_line.context_snapshot.to_logfmt(
+              :except => [Contexts::Servers::HerokuSpecific]
+            )
+          end
+      end
+    end
+  end
+end