timberio 1.0.0.beta1

data/lib/timber/api_settings.rb

@@ -0,0 +1,17 @@
+module Timber
+  # These settings are established by the Timber API. Changing these will result
+  # in unsuccessful log delivery.
+  module APISettings
+    DATE_FORMAT = :iso8601.freeze # must be a method name
+    DATE_FORMAT_PRECISION = 6 # millisecond digits
+    MESSAGE_BYTE_SIZE_MAX = 1_000_000.freeze # 1mb
+
+    # List of types that the Timber API accepts
+    BOOLEAN_TYPE = "integer".freeze
+    DATE_TYPE    = "date".freeze
+    FLOAT_TYPE   = "float".freeze
+    INTEGER_TYPE = "integer".freeze
+    NIL_TYPE     = "nil".freeze
+    STRING_TYPE  = "string".freeze
+  end
+end

data/lib/timber/bootstrap.rb

@@ -0,0 +1,45 @@
+module Timber
+  # Intermediary class between frameworks and Timber. Defines
+  # requirements and normalized the setup process.
+  class Bootstrap
+    def self.bootstrap!(*args)
+      new(*args).bootstrap!
+    rescue Exception => e
+      # Failsafe to ensure Timber never takes down the app
+      Config.logger.exception(e)
+    end
+
+    attr_reader :middleware, :insert_before
+
+    def initialize(middleware, insert_before)
+      @middleware = middleware
+      @insert_before = insert_before
+    end
+
+    def bootstrap!
+      return false unless enabled?
+      Probes.insert!(middleware, insert_before)
+      log_started
+      true
+    end
+
+    private
+      def enabled?
+        if !Config.enabled?
+          Config.logger.warn("Skipping bootstrap, Timber::Config.enabled is not true")
+          false
+        else
+          true
+        end
+      end
+
+      def log_started
+        Config.logger.info(" _,-,")
+        Config.logger.info("T_  | Timber enabled")
+        Config.logger.info("||`-'")
+        Config.logger.info("||")
+        Config.logger.info("||")
+        Config.logger.info("~~")
+      end
+  end
+end

data/lib/timber/config.rb

@@ -0,0 +1,25 @@
+module Timber
+  class Config
+    include Patterns::DelegatedSingleton
+
+    attr_writer :application_key, :enabled, :logger
+
+    def application_key
+      @application_key ||= ENV['TIMBER_KEY']
+    end
+
+    def enabled
+      return @enabled if defined?(@enabled)
+      @enabled = true
+    end
+
+    def enabled?
+      enabled == true
+    end
+
+    # Internal logger for the Timber library, only for debugging purposes.
+    def logger
+      @logger ||= InternalLogger.new(nil)
+    end
+  end
+end

data/lib/timber/context.rb

@@ -0,0 +1,76 @@
+require "securerandom"
+
+module Timber
+  class Context
+    include Patterns::ToJSON
+    include Patterns::ToLogfmt
+
+    PATH_DELIMITER = ".".freeze
+    SECURE_RANDOM_LENGTH = 16.freeze
+
+    class << self
+      def json_shell(&_block)
+        {_root_key => yield}
+      end
+
+      def _path
+        @path ||= Macros::LogfmtEncoder.encode(json_shell { 1 }).split("=").first
+      end
+
+      def _root_key
+        @_root_key ||= const_get(:ROOT_KEY)
+      end
+
+      def _version
+        @_version ||= const_get(:VERSION)
+      end
+    end
+
+    def _dt
+      @_dt ||= Time.now.utc
+    end
+
+    def _path
+      self.class._path
+    end
+
+    def _version
+      self.class._version
+    end
+
+    def _root_key
+      self.class._root_key
+    end
+
+    def as_json(*args)
+      @as_json ||= json_shell { super }
+    end
+
+    def json_shell(&block)
+      self.class.json_shell(&block)
+    end
+
+    def inspect(*_args)
+      "#<#{self.class.name}:#{object_id} ...>"
+    end
+
+    # Some contexts hold mutable object that change as the context block
+    # executes. This method checks the state of that object to ensure
+    # that the context is valid and ready to be copied for each log line.
+    def valid?
+      true
+    end
+
+    private
+      def json_payload
+        @json_payload ||= {
+          :_dt => Macros::DateFormatter.format(_dt),
+          :_version => _version
+        }
+      end
+
+      def generate_secure_random
+        SecureRandom.urlsafe_base64(SECURE_RANDOM_LENGTH)
+      end
+  end
+end

data/lib/timber/context_snapshot.rb

@@ -0,0 +1,64 @@
+module Timber
+  class ContextSnapshot
+    include Timber::Patterns::ToJSON
+
+    CONTEXT_VERSION = 1.freeze
+
+    attr_reader :indexes, :stack
+
+    def initialize
+      # Cloning arrays and hashes is extremely fast. This
+      # should not be a concern for hindering performance as we are
+      # only cloning the structures, not the content.
+      @stack = CurrentContext.valid_stack.clone.freeze
+      @indexes = CurrentLineIndexes.indexes.clone.freeze
+    end
+
+    def to_logfmt(options = {})
+      @to_logfmt ||= {}
+      @to_logfmt[options] ||= begin
+        items = stack.collect do |context|
+          next if options[:except].is_a?(Array) && options[:except].include?(context.class)
+          # Delegate to #to_logfmt on the context object for caching.
+          # Add the index on the fly, as a string, since it's more performant.
+          Macros::LogfmtEncoder.join(context.to_logfmt, "#{context._path}._index=#{index(context)}")
+        end.compact
+        items << Macros::LogfmtEncoder.encode(:_version => CONTEXT_VERSION, :_hierarchy => hierarchy)
+        Macros::LogfmtEncoder.join(*items)
+      end
+    end
+
+    def size
+      stack.size
+    end
+
+    private
+      def context_hash
+        @context_hash ||= begin
+          hash = stack.inject({}) do |acc, context|
+            acc = Macros::DeepMerger.merge(acc, context.as_json)
+            Macros::DeepMerger.merge(acc, index_hash(context))
+          end
+          hash[:_version] = CONTEXT_VERSION
+          hash[:_hierarchy] = hierarchy
+          hash
+        end
+      end
+
+      def hierarchy
+        @hierarchy ||= stack.collect(&:_path).uniq
+      end
+
+      def index(context)
+        indexes[context] || raise("couldn't find index for #{context}")
+      end
+
+      def index_hash(context)
+        context.json_shell { {:_index => index(context)}}
+      end
+
+      def json_payload
+        @json_payload ||= {:context => context_hash}
+      end
+  end
+end

data/lib/timber/contexts/dynamic_values.rb

@@ -0,0 +1,59 @@
+require "bigdecimal"
+require "date"
+
+module Timber
+  module Contexts
+    class DynamicValues
+      class UnrecognizedObjectTypeError < StandardError; end
+
+      include Patterns::ToJSON
+
+      BOOLEAN_TYPES = [FalseClass, TrueClass].freeze
+      DATE_TYPES    = [Date, Time].freeze
+      FLOAT_TYPES   = [BigDecimal, Float].freeze
+      INTEGER_TYPES = [Fixnum].freeze
+      NIL_TYPES     = [NilClass].freeze
+      STRING_TYPES  = [String].freeze
+
+      def initialize(values_array = nil)
+        @values_array = values_array
+      end
+
+      private
+        def json_payload
+          @json_payload ||= values_array.collect do |value|
+            to_item(value)
+          end
+        end
+
+        def to_item(value)
+          {
+            :name  => value[:name],
+            :type  => type(value[:value]),
+            :value => value[:value]
+          }
+        end
+
+        def type(value)
+          # Using is_a? because it checks the entire hierarchy, unlike a case statement.
+          if BOOLEAN_TYPES.any? { |type| value.is_a?(type) }
+            APISettings::BOOLEAN_TYPE
+          elsif DATE_TYPES.any? { |type| value.is_a?(type) }
+            APISettings::DATE_TYPE
+          elsif FLOAT_TYPES.any? { |type| value.is_a?(type) }
+            APISettings::FLOAT_TYPE
+          elsif INTEGER_TYPES.any? { |type| value.is_a?(type) }
+            APISettings::INTEGER_TYPE
+          elsif NIL_TYPES.any? { |type| value.is_a?(type) }
+            APISettings::NIL_TYPE
+          else
+            APISettings::STRING_TYPE
+          end
+        end
+
+        def values_array
+          @values_array
+        end
+    end
+  end
+end

data/lib/timber/contexts/exception.rb

@@ -0,0 +1,40 @@
+module Timber
+  module Contexts
+    class Exception < Context
+      ROOT_KEY = :exception.freeze
+      VERSION = 1.freeze
+
+      attr_reader :exception
+
+      def initialize(exception)
+        # Initialize should be as fast as possible since it is executed inline.
+        # Hence the lazy methods below.
+        @exception = exception
+        super()
+      end
+
+      def backtrace
+        # only the first 5 lines to save on space
+        @backtrace ||= exception.backtrace[0..4]
+      end
+
+      def name
+        @name ||= exception.class.name
+      end
+
+      def message
+        @message ||= exception.message
+      end
+
+      private
+        def json_payload
+          @json_payload ||= Macros::DeepMerger.merge({
+            # order is relevant for logfmt styling
+            :name => name,
+            :message => message,
+            :backtrace => backtrace
+          }, super).freeze
+        end
+    end
+  end
+end

data/lib/timber/contexts/http_request.rb

@@ -0,0 +1,22 @@
+module Timber
+  module Contexts
+    class HTTPRequest < Context
+      ROOT_KEY = :http_request.freeze
+      VERSION = 1.freeze
+
+      private
+        def json_payload
+          @json_payload ||= Macros::DeepMerger.merge({
+            # order is relevant for logfmt styling
+            :method => method,
+            :scheme => scheme,
+            :host => host,
+            :port => port,
+            :path => path,
+            :query_params => query_params.as_json,
+            :headers => headers.as_json
+          }, super).freeze
+        end
+    end
+  end
+end

data/lib/timber/contexts/http_requests/action_controller_specific.rb

@@ -0,0 +1,48 @@
+module Timber
+  module Contexts
+    module HTTPRequests
+      # Extend Context since we are a sub context and not an actual HTTPRequest
+      class ActionControllerSpecific < Context
+        ROOT_KEY = :action_controller.freeze
+        VERSION = 1.freeze
+
+        class << self
+          def json_shell(&_block)
+            Rack.json_shell { super }
+          end
+        end
+
+        attr_reader :controller_obj
+
+        def initialize(controller_obj)
+          # Initialize should be as fast as possible since it is executed inline.
+          # Hence the lazy methods below.
+          @controller_obj = controller_obj
+          super()
+        end
+
+        def action
+          @action ||= controller_obj.action_name
+        end
+
+        def controller
+          @controller ||= controller_obj.class.name
+        end
+
+        def format
+          @format ||= controller_obj.request.format.try(:ref)
+        end
+
+        private
+          def json_payload
+            @json_payload ||= Macros::DeepMerger.merge({
+              # order is relevant for logfmt styling
+              :controller => controller,
+              :action => action,
+              :format => format
+            }, super).freeze
+          end
+      end
+    end
+  end
+end

data/lib/timber/contexts/http_requests/rack/params.rb

@@ -0,0 +1,26 @@
+module Timber
+  module Contexts
+    module HTTPRequests
+      class Rack < HTTPRequest
+        class Params < DynamicValues
+          attr_reader :params
+
+          def initialize(params)
+            # Initialize should be as fast as possible since it is executed inline.
+            # Hence the lazy methods below.
+            @params = params
+            super()
+          end
+
+          private
+            # Override values_array so that this is done in the background thread
+            def values_array
+              @values_array ||= params.collect do |key, value|
+                {:name => key, :value => value}
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/timber/contexts/http_requests/rack.rb

@@ -0,0 +1,105 @@
+require "timber/contexts/http_requests/rack/params"
+
+module Timber
+  module Contexts
+    module HTTPRequests
+      class Rack < HTTPRequest
+        class Headers
+          include Patterns::ToJSON
+
+          attr_reader :env, :request
+
+          def initialize(env, request)
+            @env = env
+            @request = request
+          end
+
+          def content_type
+            @content_type ||= request.content_type
+          end
+
+          def referrer
+            @referrer ||= request.referrer
+          end
+
+          def remote_addr
+            @remote_addr ||= request.ip
+          end
+
+          def request_id
+            return @request_id if defined?(@request_id)
+            found = env.find do |k,v|
+              # Needs to support:
+              # action_dispatch.request_id
+              # HTTP_X_REQUEST_ID
+              # Request-ID
+              # Request-Id
+              # X-Request-ID
+              # X-Request-Id
+              # etc
+              (k.downcase.include?("request_id") || k.downcase.include?("request-id")) && !v.nil?
+            end
+            @request_id = found && found.last
+          end
+
+          def user_agent
+            @user_agent ||= request.user_agent
+          end
+
+          private
+            def json_payload
+              @json_payload ||= {
+                :content_type => content_type,
+                :referrer => referrer,
+                :remote_addr => remote_addr,
+                :request_id => request_id,
+                :user_agent => user_agent
+              }
+            end
+        end
+
+        attr_reader :env
+
+        def initialize(env)
+          # Initialize should be as fast as possible since it is executed inline.
+          # Hence the lazy methods below.
+          @env = env
+          super()
+        end
+
+        def headers
+          @headers ||= Headers.new(env, request)
+        end
+
+        def host
+          @host ||= request.host
+        end
+
+        def method
+          @method ||= request.request_method.upcase
+        end
+
+        def path
+          @path ||= request.path
+        end
+
+        def port
+          @port ||= request.port
+        end
+
+        def query_params
+          @query_params ||= request.params && Params.new(request.params)
+        end
+
+        def scheme
+          @scheme ||= request.scheme
+        end
+
+        private
+          def request
+            @request ||= ::Rack::Request.new(env)
+          end
+      end
+    end
+  end
+end

data/lib/timber/contexts/http_response.rb

@@ -0,0 +1,19 @@
+module Timber
+  module Contexts
+    # Generica HTTP response shared across all platforms.
+    class HTTPResponse < Context
+      ROOT_KEY = :http_response.freeze
+      VERSION = 1.freeze
+
+      private
+        def json_payload
+          @json_payload ||= Macros::DeepMerger.merge({
+            # order is relevant for logfmt styling
+            :status => status,
+            :headers => headers.as_json,
+            :time_ms => time_ms
+          }, super).freeze
+        end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Timber
+  module Contexts
+    module HTTPResponses
+      class ActionController < HTTPResponse
+        class Headers
+          include Patterns::ToJSON
+
+          attr_reader :response
+
+          def initialize(response)
+            @response = response
+          end
+
+          def content_length
+            @content_length ||= response.content_length
+          end
+
+          def cache_control
+            @cache_control ||= response.headers['Cache-Control']
+          end
+
+          def content_disposition
+            @content_disposition ||= response.headers['Cache-Disposition']
+          end
+
+          def content_type
+            @content_type ||= response.headers['Content-Type']
+          end
+
+          def location
+            @location ||= response.headers['Location']
+          end
+
+          private
+            def json_payload
+              @json_payload ||= {
+                :content_length => content_length,
+                :cache_control => cache_control,
+                :content_disposition => content_disposition,
+                :content_type => content_type,
+                :location => location
+              }
+            end
+        end
+
+        attr_reader :controller
+        attr_accessor :event
+
+        def initialize(controller)
+          @controller = controller
+        end
+
+        def headers
+          @headers ||= Headers.new(response)
+        end
+
+        def status
+          @status ||= response.status
+        end
+
+        def time_ms
+          @time_ms ||= event.duration
+        end
+
+        def valid?
+          !response.nil? && !event.nil?
+        end
+
+        private
+          def response
+            controller.response
+          end
+      end
+    end
+  end
+end

data/lib/timber/contexts/logger.rb

@@ -0,0 +1,33 @@
+module Timber
+  module Contexts
+    class Logger < Context
+      ROOT_KEY = :logger.freeze
+      VERSION = 1.freeze
+      LEVEL_MAP = {
+        0 => "debug",
+        1 => "info",
+        2 => "warn",
+        3 => "error",
+        4 => "fatal"
+      }
+      UNKNOWN_LEVEL = "unknown"
+
+      attr_reader :level, :progname
+
+      def initialize(level, progname)
+        @level = LEVEL_MAP[level] || UNKNOWN_LEVEL
+        @progname = progname
+        super()
+      end
+
+      private
+        def json_payload
+          @json_payload ||= Macros::DeepMerger.merge({
+            # order is relevant for logfmt styling
+            :level => level,
+            :progname => progname
+          }, super).freeze
+        end
+    end
+  end
+end

data/lib/timber/contexts/organization.rb

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