timber 2.5.1 → 2.6.0.pre.beta1

data/lib/timber/events/error.rb

@@ -8,24 +8,24 @@ module Timber
     # @note This event should be installed automatically through integrations,
     #   such as the {Integrations::ActionDispatch::DebugExceptions} integration.
     class Error < Timber::Event
-      MAX_MESSAGE_BYTES = 8192.freeze
+      BACKTRACE_JSON_MAX_BYTES = 8192.freeze
+      MESSAGE_MAX_BYTES = 8192.freeze
 
       attr_reader :name, :error_message, :backtrace
 
       def initialize(attributes)
-        @name = attributes[:name] || raise(ArgumentError.new(":name is required"))
-
-        @error_message = attributes[:error_message] || raise(ArgumentError.new(":error_message is required"))
-        @error_message = @error_message.byteslice(0, MAX_MESSAGE_BYTES)
-
-        backtrace = attributes[:backtrace]
-        if !backtrace.nil? && backtrace != []
-          @backtrace = backtrace[0..9].collect { |line| parse_backtrace_line(line) }
-        end
+        normalizer = Util::AttributeNormalizer.new(attributes)
+        @name = normalizer.fetch!(:name, :string)
+        @error_message = normalizer.fetch!(:error_message, :string, :limit => MESSAGE_MAX_BYTES)
+        @backtrace = normalizer.fetch(:backtrace, :array)
       end
 
       def to_hash
-        {name: name, message: error_message, backtrace: backtrace}
+        @to_hash ||= Util::NonNilHashBuilder.build do |h|
+          h.add(:name, name)
+          h.add(:message, error_message)
+          h.add(:backtrace_json, backtrace, :json_encode => true, :limit => BACKTRACE_JSON_MAX_BYTES)
+        end
       end
       alias to_h to_hash
 
@@ -37,26 +37,6 @@ module Timber
       def message
         "#{name} (#{error_message})"
       end
-
-      private
-        def parse_backtrace_line(line)
-          # using split for performance reasons
-          file, line, function_part = line.split(":", 3)
-
-          parsed_line = {file: file}
-
-          if line
-            parsed_line[:line] = line.to_i
-          end
-
-          if function_part
-            _prefix, function_pre = function_part.split("`", 2)
-            function = Util::Object.try(function_pre, :chomp, "'")
-            parsed_line[:function] = function
-          end
-
-          parsed_line
-        end
     end
   end
 end

data/lib/timber/events/http_request.rb

@@ -9,26 +9,52 @@ module Timber
     # @note This event should be installed automatically through integrations,
     #   such as the {Integrations::ActionController::LogSubscriber} integration.
     class HTTPRequest < Timber::Event
+      BODY_MAX_BYTES = 8192.freeze
+      HEADERS_JSON_MAX_BYTES = 8192.freeze
+      HEADERS_TO_SANITIZE = ['authorization', 'x-amz-security-token'].freeze
+      HOST_MAX_BYTES = 256.freeze
+      METHOD_MAX_BYTES = 20.freeze
+      PATH_MAX_BYTES = 2048.freeze
+      QUERY_STRING_MAX_BYTES = 2048.freeze
+      REQUEST_ID_MAX_BYTES = 256.freeze
+      SCHEME_MAX_BYTES = 20.freeze
+      SERVICE_NAME_MAX_BYTES = 256.freeze
+
       attr_reader :body, :content_length, :headers, :host, :method, :path, :port, :query_string,
         :request_id, :scheme, :service_name
 
       def initialize(attributes)
-        @body = attributes[:body] && Util::HTTPEvent.normalize_body(attributes[:body])
-        @content_length = Timber::Util::Object.try(attributes[:content_length], :to_i)
-        @headers = Util::HTTPEvent.normalize_headers(attributes[:headers])
-        @host = attributes[:host]
-        @method = Util::HTTPEvent.normalize_method(attributes[:method]) || raise(ArgumentError.new(":method is required"))
-        @path = attributes[:path]
-        @port = attributes[:port]
-        @query_string = Util::HTTPEvent.normalize_query_string(attributes[:query_string])
-        @scheme = attributes[:scheme]
-        @request_id = attributes[:request_id]
+        normalizer = Util::AttributeNormalizer.new(attributes)
+        body_limit = Config.instance.http_body_limit || BODY_MAX_BYTES
+        headers_to_sanitize = HEADERS_TO_SANITIZE + (Config.instance.http_header_filters || [])
+
+        @body = normalizer.fetch(:body, :string, :limit => body_limit)
+        @content_length = normalizer.fetch(:content_length, :integer)
+        @headers = normalizer.fetch(:headers, :hash, :sanitize => headers_to_sanitize)
+        @host = normalizer.fetch(:host, :string, :limit => HOST_MAX_BYTES)
+        @method = normalizer.fetch!(:method, :string, :upcase => true, :limit => METHOD_MAX_BYTES)
+        @path = normalizer.fetch(:path, :string, :limit => PATH_MAX_BYTES)
+        @port = normalizer.fetch(:port, :integer)
+        @query_string = normalizer.fetch(:query_string, :string, :limit => QUERY_STRING_MAX_BYTES)
+        @scheme = normalizer.fetch(:scheme, :string, :limit => SCHEME_MAX_BYTES)
+        @request_id = normalizer.fetch(:request_id, :string, :limit => REQUEST_ID_MAX_BYTES)
+        @service_name = normalizer.fetch(:service_name, :string, :limit => SERVICE_NAME_MAX_BYTES)
       end
 
       def to_hash
-        {body: body, content_length: content_length, headers: headers, host: host, method: method,
-          path: path, port: port, query_string: query_string, request_id: request_id,
-          scheme: scheme}
+        @to_hash ||= Util::NonNilHashBuilder.build do |h|
+          h.add(:body, body)
+          h.add(:content_length, content_length)
+          h.add(:headers_json, headers, :json_encode => true, :limit => HEADERS_JSON_MAX_BYTES)
+          h.add(:host, host)
+          h.add(:method, method)
+          h.add(:path, path)
+          h.add(:port, port)
+          h.add(:query_string, query_string)
+          h.add(:request_id, request_id)
+          h.add(:scheme, scheme)
+          h.add(:service_name, service_name)
+        end
       end
       alias to_h to_hash
 

data/lib/timber/events/http_response.rb

@@ -9,22 +9,40 @@ module Timber
     # @note This event should be installed automatically through integrations,
     #   such as the {Integrations::ActionController::LogSubscriber} integration.
     class HTTPResponse < Timber::Event
-      attr_reader :body, :content_length, :headers, :http_context, :request_id, :service_name, :status, :time_ms
+      BODY_MAX_BYTES = 8192.freeze
+      HEADERS_JSON_MAX_BYTES = 256.freeze
+      HEADERS_TO_SANITIZE = ['authorization', 'x-amz-security-token'].freeze
+      REQUEST_ID_MAX_BYTES = 256.freeze
+      SERVICE_NAME_MAX_BYTES = 256.freeze
+
+      attr_reader :body, :content_length, :headers, :http_context, :request_id, :service_name,
+        :status, :time_ms
 
       def initialize(attributes)
-        @body = attributes[:body] && Util::HTTPEvent.normalize_body(attributes[:body])
-        @content_length = Timber::Util::Object.try(attributes[:content_length], :to_i)
-        @headers = Util::HTTPEvent.normalize_headers(attributes[:headers])
+        normalizer = Util::AttributeNormalizer.new(attributes)
+        body_limit = Config.instance.http_body_limit || BODY_MAX_BYTES
+        headers_to_sanitize = HEADERS_TO_SANITIZE + (Config.instance.http_header_filters || [])
+
+        @body = normalizer.fetch(:body, :string, :limit => body_limit)
+        @content_length = normalizer.fetch(:content_length, :integer)
+        @headers = normalizer.fetch(:headers, :hash, :sanitize => headers_to_sanitize)
         @http_context = attributes[:http_context]
-        @request_id = attributes[:request_id]
-        @status = attributes[:status] || raise(ArgumentError.new(":status is required"))
-        @time_ms = attributes[:time_ms] || raise(ArgumentError.new(":time_ms is required"))
-        @time_ms = @time_ms.round(6)
+        @request_id = normalizer.fetch(:request_id, :string, :limit => REQUEST_ID_MAX_BYTES)
+        @service_name = normalizer.fetch(:service_name, :string, :limit => SERVICE_NAME_MAX_BYTES)
+        @status = normalizer.fetch!(:status, :integer)
+        @time_ms = normalizer.fetch!(:time_ms, :float, :precision => 6)
       end
 
       def to_hash
-        {body: body, content_length: content_length, headers: headers, request_id: request_id,
-          status: status, time_ms: time_ms}
+        @to_hash ||= Util::NonNilHashBuilder.build do |h|
+          h.add(:body, body)
+          h.add(:content_length, content_length)
+          h.add(:headers_json, headers, :json_encode => true, :limit => HEADERS_JSON_MAX_BYTES)
+          h.add(:request_id, request_id)
+          h.add(:service_name, service_name)
+          h.add(:status, status)
+          h.add(:time_ms, time_ms)
+        end
       end
       alias to_h to_hash
 
@@ -40,18 +58,18 @@ module Timber
             "#{status} #{status_description} "
 
           if content_length
-            message += ", #{content_length} bytes, "
+            message << ", #{content_length} bytes, "
           end
 
-          message + "in #{time_ms}ms"
+          message << "in #{time_ms}ms"
         else
           message = "Completed #{status} #{status_description} "
 
           if content_length
-            message += ", #{content_length} bytes, "
+            message << ", #{content_length} bytes, "
           end
 
-          message + "in #{time_ms}ms"
+          message << "in #{time_ms}ms"
         end
       end
 

data/lib/timber/events/sql_query.rb

@@ -7,20 +7,23 @@ module Timber
     # @note This event should be installed automatically through integrations,
     #   such as the {Integrations::ActiveRecord::LogSubscriber} integration.
     class SQLQuery < Timber::Event
-      MAX_QUERY_BYTES = 1024.freeze
+      MESSAGE_MAX_BYTES = 8192.freeze
+      SQL_MAX_BYTES = 4096.freeze
 
       attr_reader :sql, :time_ms, :message
 
       def initialize(attributes)
-        @sql = attributes[:sql] || raise(ArgumentError.new(":sql is required"))
-        @sql = @sql.byteslice(0, MAX_QUERY_BYTES)
-        @time_ms = attributes[:time_ms] || raise(ArgumentError.new(":time_ms is required"))
-        @time_ms = @time_ms.round(6)
-        @message = attributes[:message] || raise(ArgumentError.new(":message is required"))
+        normalizer = Util::AttributeNormalizer.new(attributes)
+        @message = normalizer.fetch!(:message, :string, :limit => MESSAGE_MAX_BYTES)
+        @sql = normalizer.fetch!(:sql, :string, :limit => SQL_MAX_BYTES)
+        @time_ms = normalizer.fetch!(:time_ms, :float, :precision => 6)
       end
 
       def to_hash
-        {sql: sql, time_ms: time_ms}
+        @to_hash ||= Util::NonNilHashBuilder.build do |h|
+          h.add(:sql, sql)
+          h.add(:time_ms, time_ms)
+        end
       end
       alias to_h to_hash
 

data/lib/timber/events/template_render.rb

@@ -7,17 +7,23 @@ module Timber
     # @note This event should be installed automatically through integrations,
     #   such as the {Integrations::ActionView::LogSubscriber} integration.
     class TemplateRender < Timber::Event
+      MESSAGE_MAX_BYTES = 8192.freeze
+      NAME_MAX_BYTES = 1024.freeze
+
       attr_reader :message, :name, :time_ms
 
       def initialize(attributes)
-        @message = attributes[:message] || raise(ArgumentError.new(":message is required"))
-        @name = attributes[:name] || raise(ArgumentError.new(":name is required"))
-        @time_ms = attributes[:time_ms] || raise(ArgumentError.new(":time_ms is required"))
-        @time_ms = @time_ms.round(6)
+        normalizer = Util::AttributeNormalizer.new(attributes)
+        @message = normalizer.fetch!(:message, :string, :limit => MESSAGE_MAX_BYTES)
+        @name = normalizer.fetch!(:name, :string, :limit => NAME_MAX_BYTES)
+        @time_ms = normalizer.fetch!(:time_ms, :float, :precision => 6)
       end
 
       def to_hash
-        {name: name, time_ms: time_ms}
+        @to_hash ||= Util::NonNilHashBuilder.build do |h|
+          h.add(:name, name)
+          h.add(:time_ms, time_ms)
+        end
       end
       alias to_h to_hash
 

data/lib/timber/log_entry.rb

@@ -13,7 +13,7 @@ module Timber
     MESSAGE_MAX_BYTES = 8192.freeze
     SCHEMA = "https://raw.githubusercontent.com/timberio/log-event-json-schema/v3.2.0/schema.json".freeze
 
-    attr_reader :context_snapshot, :event, :level, :message, :progname, :tags, :time, :time_ms
+    attr_reader :context_snapshot, :event, :level, :message, :progname, :tags, :time
 
     # Creates a log entry suitable to be sent to the Timber API.
     # @param level [Integer] the log level / severity
@@ -36,7 +36,6 @@ module Timber
       @message = message.is_a?(String) ? message : message.inspect
       @message = @message.byteslice(0, MESSAGE_MAX_BYTES)
       @tags = options[:tags]
-      @time_ms = options[:time_ms]
       @context_snapshot = context_snapshot
       @event = event
     end
@@ -47,11 +46,13 @@ module Timber
       hash = {
         :level => level,
         :dt => formatted_dt,
-        :message => message,
-        :tags => tags,
-        :time_ms => time_ms
+        :message => message
       }
 
+      if !tags.nil? && tags.length > 0
+        hash[:tags] = tags
+      end
+
       if !event.nil?
         hash[:event] = event.as_json
       end
@@ -62,7 +63,7 @@ module Timber
 
       hash[:"$schema"] = SCHEMA
 
-      hash = if options[:only]
+      if options[:only]
         hash.select do |key, _value|
           options[:only].include?(key)
         end
@@ -73,31 +74,6 @@ module Timber
       else
         hash
       end
-
-      # Preparing a log event for JSON should remove any blank values. Timber strictly
-      # validates incoming data, including message size. Blank values will fail validation.
-      # Moreover, binary data (ASCII-8BIT) generally cannot be encoded into JSON because it
-      # contains characters outside of the valid UTF-8 space.
-      Util::Hash.deep_reduce(hash) do |k, v, h|
-        # Discard blank values
-        if !v.nil? && (!v.respond_to?(:length) || v.length > 0)
-          # If the value is a binary string, give it special treatment
-          if v.respond_to?(:encoding) && v.encoding == ::Encoding::ASCII_8BIT
-            # Only keep binary values less than a certain size. Sizes larger than this
-            # are almost always file uploads and data we do not want to log.
-            if v.length < BINARY_LIMIT_THRESHOLD
-              # Attempt to safely encode the data to UTF-8
-              encoded_value = encode_string(v)
-              if !encoded_value.nil?
-                h[k] = encoded_value
-              end
-            end
-          else
-            # Keep all other values
-            h[k] = v
-          end
-        end
-      end
     end
 
     def inspect

data/lib/timber/logger.rb

@@ -47,15 +47,11 @@ module Timber
             tags.concat(logged_obj.delete(:tags)) if logged_obj.key?(:tags)
             tags.uniq!
 
-            # Extract the time_ms
-            time_ms = logged_obj.delete(:time_ms)
-
             # Build the event
             event = Events.build(logged_obj)
             message = event ? event.message : logged_obj[:message]
 
-            LogEntry.new(level, time, progname, message, context_snapshot, event, tags: tags,
-              time_ms: time_ms)
+            LogEntry.new(level, time, progname, message, context_snapshot, event, tags: tags)
           else
             LogEntry.new(level, time, progname, logged_obj, context_snapshot, nil, tags: tags)
           end

data/lib/timber/util.rb

@@ -1,7 +1,7 @@
 require "timber/util/active_support_log_subscriber"
+require "timber/util/attribute_normalizer"
 require "timber/util/hash"
-require "timber/util/http_event"
-require "timber/util/object"
+require "timber/util/non_nil_hash_builder"
 require "timber/util/request"
 require "timber/util/struct"
 

data/lib/timber/util/attribute_normalizer.rb

@@ -0,0 +1,90 @@
+module Timber
+  module Util
+    # @private
+    #
+    # The purpose of this class is to normalize parameters passed to events
+    # and contexts. Timber validates a rigid JSON schema against the defined
+    # Timber log event JSON schema. This normalization process ensures the
+    # data passed to events and contexts conforms to this structure.
+    class AttributeNormalizer
+      def initialize(attributes)
+        @attributes = attributes
+      end
+
+      def fetch!(key, type, options = {})
+        v = fetch(key, type, options)
+        if v.nil?
+          raise @attributes.inspect
+          raise ArgumentError.new("The #{key.inspect} attribute is required")
+        end
+        v
+      end
+
+      def fetch(key, type, options = {})
+        v = @attributes[key]
+
+        if blank?(v)
+          nil
+        else
+          case type
+          when :array
+            if !v.is_a?(Array)
+              raise ArgumentError.new("The #{key.inspect} attribute must be a list if provided")
+            end
+
+            v
+
+          when :float
+            v = v.to_f
+
+            if options[:precision]
+              v = v.round(options[:precision])
+            end
+
+            v
+
+          when :hash
+            if options[:sanitize]
+              v = Util::Hash.sanitize_keys(v, options[:sanitize])
+            end
+
+            v = Util::Hash.jsonify(v)
+
+            if v == {}
+              nil
+            else
+              v
+            end
+
+          when :integer
+            v.to_i
+
+          when :string
+            v = v.to_s
+
+            if options[:limit]
+              v = v.byteslice(0, options[:limit])
+            end
+
+            if options[:upcase]
+              v = v.upcase
+            end
+
+            v
+
+          when :symbol
+            v.to_sym
+
+          else
+            raise ArgumentError.new("Unknown normalization type #{type}")
+          end
+        end
+      end
+
+      private
+        def blank?(v)
+          v.nil? || (v.respond_to?(:length) && v.length == 0)
+        end
+    end
+  end
+end