timber 2.5.1 → 2.6.0.pre.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a87f39b30172987e5484e2cc7a7b8141df304872
-  data.tar.gz: cbc461a99678fd533074bf6b8e9fdf91d4003bab
+  metadata.gz: 10838667c7f285fea9c51270f12594b2106299e1
+  data.tar.gz: f91eaaac75c0ed243686771c415a3f44d6c431b3
 SHA512:
-  metadata.gz: d5af9920a09c610cc4fcdfb22c38db8b99e25f1b4232ed3c70350ec63965facef2ccd3f580e4b72cb08a8c795bcf8038a5ddc3ce22ea1c26968dc54f2453fe20
-  data.tar.gz: 693d57eba475629b40c9bbbf639ebc6f87af2298eea376b9cc881a76ea224eeb75b0b9d08377a3ebde2d05854ce1d1c006c32679072cd5a721b7c80fc41e1848
+  metadata.gz: 8cc093229929a57566e15f4fe81a9f2fbf36c0259a85123e43cbe077e9a14828147620b60be1a7953560ac691923146dcccb2075adbe64fb331bae9a1e388206
+  data.tar.gz: 5478c747ded3aa62d3fcf0b877e5e09bccafb94c72e1b4812b2dea0cac2aa5fe2e86435532c66f16b35596178c64d2502a40687fe97437f13e6db641cbb296b8

data/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+## [2.6.0-beta1] - 2017-10-28
+
+### Fixed
+
+  - Encoding and rewind issues for file upload parameters have been resolved. Timber
+    improved attribute normalization across all contexts and events, ignoring binary
+    values like this in general.
+
 ## [2.5.1] - 2017-10-27
 
 ### Fixed
@@ -103,7 +111,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
     instead of applying back pressure.
 
 
-[Unreleased]: https://github.com/timberio/timber-ruby/compare/v2.5.1...HEAD
+[Unreleased]: https://github.com/timberio/timber-ruby/compare/v2.6.0-beta1...HEAD
+[2.6.0-beta1]: https://github.com/timberio/timber-ruby/compare/v2.5.1...v2.6.0-beta1
 [2.5.1]: https://github.com/timberio/timber-ruby/compare/v2.5.0...v2.5.1
 [2.5.0]: https://github.com/timberio/timber-ruby/compare/v2.4.0...v2.5.0
 [2.4.0]: https://github.com/timberio/timber-ruby/compare/v2.3.4...v2.4.0

data/lib/timber/config.rb

@@ -25,6 +25,7 @@ module Timber
       end
     end
 
+    DEFAULT_HTTP_BODY_LIMIT = 2048.freeze
     DEVELOPMENT_NAME = "development".freeze
     PRODUCTION_NAME = "production".freeze
     STAGING_NAME = "staging".freeze
@@ -36,7 +37,7 @@ module Timber
 
     # @private
     def initialize
-      @http_body_limit = 2048
+      @http_body_limit = DEFAULT_HTTP_BODY_LIMIT
     end
 
     # Convenience method for logging debug statements to the debug logger

data/lib/timber/contexts/custom.rb

@@ -24,13 +24,20 @@ module Timber
       attr_reader :type, :data
 
       def initialize(attributes)
-        @type = Timber::Util::Object.try(attributes[:type], :to_sym) || raise(ArgumentError.new(":type is required"))
-        @data = attributes[:data] || raise(ArgumentError.new(":data is required"))
+        normalizer = Util::AttributeNormalizer.new(attributes)
+        @type = normalizer.fetch!(:type, :symbol)
+        @data = normalizer.fetch!(:data, :hash)
       end
 
       # Builds a hash representation containing simple objects, suitable for serialization (JSON).
+      def to_hash
+        @to_hash ||= Util::NonNilHashBuilder.build do |h|
+          h.add(type, data)
+        end
+      end
+
       def as_json(options = {})
-        {type => data}
+        to_hash
       end
     end
   end

data/lib/timber/contexts/http.rb

@@ -13,22 +13,38 @@ module Timber
     # @note This context should be installed automatically through the,
     #   {Intregrations::Rack::HTTPContext} Rack middleware.
     class HTTP < Context
+      HOST_MAX_BYTES = 256.freeze
+      METHOD_MAX_BYTES = 20.freeze
+      PATH_MAX_BYTES = 2048.freeze
+      REMOTE_ADDR_MAX_BYTES = 256.freeze
+      REQUEST_ID_MAX_BYTES = 256.freeze
+
       @keyspace = :http
 
       attr_reader :host, :method, :path, :remote_addr, :request_id
 
       def initialize(attributes)
-        @host = attributes[:host]
-        @method = attributes[:method] || raise(ArgumentError.new(":method is required"))
-        @path = attributes[:path]
-        @remote_addr = attributes[:remote_addr]
-        @request_id = attributes[:request_id]
+        normalizer = Util::AttributeNormalizer.new(attributes)
+        @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)
+        @remote_addr = normalizer.fetch(:remote_addr, :string, :limit => REMOTE_ADDR_MAX_BYTES)
+        @request_id = normalizer.fetch(:request_id, :string, :limit => REQUEST_ID_MAX_BYTES)
       end
 
       # Builds a hash representation containing simple objects, suitable for serialization (JSON).
+      def to_hash
+        @to_hash ||= Util::NonNilHashBuilder.build do |h|
+          h.add(:host, host)
+          h.add(:method, method)
+          h.add(:path, path)
+          h.add(:remote_addr, remote_addr)
+          h.add(:request_id, request_id)
+        end
+      end
+
       def as_json(_options = {})
-        {:host => host, :method => method, :path => path, :remote_addr => remote_addr,
-          :request_id => request_id}
+        to_hash
       end
     end
   end

data/lib/timber/contexts/organization.rb

@@ -19,18 +19,29 @@ module Timber
     #   end
     #
     class Organization < Context
+      ID_MAX_BYTES = 256.freeze
+      NAME_MAX_BYTES = 256.freeze
+
       @keyspace = :organization
 
       attr_reader :id, :name
 
       def initialize(attributes)
-        @id = Timber::Util::Object.try(attributes[:id], :to_s)
-        @name = attributes[:name]
+        normalizer = Util::AttributeNormalizer.new(attributes)
+        @id = normalizer.fetch(:id, :string, :limit => ID_MAX_BYTES)
+        @name = normalizer.fetch(:name, :string, :limit => NAME_MAX_BYTES)
       end
 
       # Builds a hash representation containing simple objects, suitable for serialization (JSON).
+      def to_hash
+        @to_hash ||= Util::NonNilHashBuilder.build do |h|
+          h.add(:id, id)
+          h.add(:name, name)
+        end
+      end
+
       def as_json(_options = {})
-        {id: id, name: name}
+        to_hash
       end
     end
   end

data/lib/timber/contexts/release.rb

@@ -8,6 +8,10 @@ module Timber
     #
     # @note To automatically set this context, see {.from_env}.
     class Release < Context
+      COMMIT_HASH_MAX_BYTES = 256.freeze
+      CREATED_AT_MAX_BYTES = 256.freeze
+      VERSION_MAX_BYTES = 256.freeze
+
       @keyspace = :release
 
       class << self
@@ -36,14 +40,23 @@ module Timber
       attr_reader :commit_hash, :created_at, :version
 
       def initialize(attributes)
-        @commit_hash = attributes[:commit_hash]
-        @created_at = attributes[:created_at]
-        @version = attributes[:version]
+        normalizer = Util::AttributeNormalizer.new(attributes)
+        @commit_hash = normalizer.fetch(:commit_hash, :string, :limit => COMMIT_HASH_MAX_BYTES)
+        @created_at = normalizer.fetch(:created_at, :string, :limit => CREATED_AT_MAX_BYTES)
+        @version = normalizer.fetch(:version, :string, :limit => VERSION_MAX_BYTES)
       end
 
       # Builds a hash representation containing simple objects, suitable for serialization (JSON).
+      def to_hash
+        @to_hash ||= Util::NonNilHashBuilder.build do |h|
+          h.add(:commit_hash, commit_hash)
+          h.add(:created_at, created_at)
+          h.add(:version, version)
+        end
+      end
+
       def as_json(_options = {})
-        {commit_hash: commit_hash, created_at: created_at, version: version}
+        to_hash
       end
     end
   end

data/lib/timber/contexts/runtime.rb

@@ -7,24 +7,43 @@ module Timber
     # origin in your code. For example, if you are debugging a specific class, you can narrow
     # by that class and see only it's logs.
     class Runtime < Context
+      APPLICATION_MAX_BYTES = 256.freeze
+      CLASS_NAME_MAX_BYTES = 256.freeze
+      FILE_MAX_BYTES = 1024.freeze
+      FUNCTION_MAX_BYTES = 256.freeze
+      MODULE_NAME_MAX_BYTES = 256.freeze
+      VM_PID_MAX_BYTES = 256.freeze
+
       @keyspace = :runtime
 
       attr_reader :application, :class_name, :file, :function, :line, :module_name, :vm_pid
 
       def initialize(attributes)
-        @application = attributes[:application]
-        @class_name = attributes[:class_name]
-        @file = attributes[:file]
-        @function = attributes[:function]
-        @line = attributes[:line]
-        @module_name = attributes[:module_name]
-        @vm_pid = Timber::Util::Object.try(attributes[:vm_pid], :to_s)
+        normalizer = Util::AttributeNormalizer.new(attributes)
+        @application = normalizer.fetch(:application, :string, :limit => APPLICATION_MAX_BYTES)
+        @class_name = normalizer.fetch(:class_name, :string, :limit => CLASS_NAME_MAX_BYTES)
+        @file = normalizer.fetch(:file, :string, :limit => FILE_MAX_BYTES)
+        @function = normalizer.fetch(:function, :string, :limit => FUNCTION_MAX_BYTES)
+        @line = normalizer.fetch(:line, :integer)
+        @module_name = normalizer.fetch(:module_name, :string, :limit => MODULE_NAME_MAX_BYTES)
+        @vm_pid = normalizer.fetch(:vm_pid, :string, :limit => VM_PID_MAX_BYTES)
       end
 
       # Builds a hash representation containing simple objects, suitable for serialization (JSON).
+      def to_hash
+        @to_hash ||= Util::NonNilHashBuilder.build do |h|
+          h.add(:application, application)
+          h.add(:class_name, class_name)
+          h.add(:file, file)
+          h.add(:function, function)
+          h.add(:line, line)
+          h.add(:module_name, module_name)
+          h.add(:vm_pid, vm_pid)
+        end
+      end
+
       def as_json(_options = {})
-        {application: application, class_name: class_name, file: file, function: function,
-          line: line, module_name: module_name, vm_pid: vm_pid}
+        to_hash
       end
     end
   end

data/lib/timber/contexts/session.rb

@@ -11,17 +11,26 @@ module Timber
     # @note This is tracked automatically with the {Integrations::Rack::SessionContext} rack
     #   middleware.
     class Session < Context
+      ID_MAX_BYTES = 256.freeze
+
       @keyspace = :session
 
       attr_reader :id
 
       def initialize(attributes)
-        @id = Timber::Util::Object.try(attributes[:id], :to_s) || raise(ArgumentError.new(":id is required"))
+        normalizer = Util::AttributeNormalizer.new(attributes)
+        @id = normalizer.fetch!(:id, :string, :limit => ID_MAX_BYTES)
       end
 
       # Builds a hash representation containing simple objects, suitable for serialization (JSON).
+      def to_hash
+        @to_hash ||= Util::NonNilHashBuilder.build do |h|
+          h.add(:id, id)
+        end
+      end
+
       def as_json(_options = {})
-        {id: id}
+        to_hash
       end
     end
   end

data/lib/timber/contexts/system.rb

@@ -8,18 +8,28 @@ module Timber
     # @note This is tracked automatically in {CurrentContext}. When the current context
     #   is initialized, the system context gets added automatically.
     class System < Context
+      HOSTNAME_MAX_BYTES = 256.freeze
+
       @keyspace = :system
 
       attr_reader :hostname, :pid
 
       def initialize(attributes)
-        @hostname = attributes[:hostname]
-        @pid = Timber::Util::Object.try(attributes[:pid], :to_i)
+        normalizer = Util::AttributeNormalizer.new(attributes)
+        @hostname = normalizer.fetch(:hostname, :string, :limit => HOSTNAME_MAX_BYTES)
+        @pid = normalizer.fetch(:pid, :integer)
       end
 
       # Builds a hash representation containing simple objects, suitable for serialization (JSON).
+      def to_hash
+        @to_hash ||= Util::NonNilHashBuilder.build do |h|
+          h.add(:hostname, hostname)
+          h.add(:pid, pid)
+        end
+      end
+
       def as_json(_options = {})
-        {hostname: hostname, pid: pid}
+        to_hash
       end
     end
   end

data/lib/timber/contexts/user.rb

@@ -11,21 +11,37 @@ module Timber
     #   middleware for supported authentication frameworks. See {Integrations::Rack::UserContext}
     #   for more details.
     class User < Context
+      ID_MAX_BYTES = 256.freeze
+      NAME_MAX_BYTES = 256.freeze
+      EMAIL_MAX_BYTES = 256.freeze
+      TYPE_MAX_BYTES = 256.freeze
+
       @keyspace = :user
 
       attr_reader :id, :name, :email, :type, :meta
 
       def initialize(attributes)
-        @id = Timber::Util::Object.try(attributes[:id], :to_s)
-        @name = attributes[:name]
-        @email = attributes[:email]
-        @type = attributes[:type]
-        @meta = attributes[:meta]
+        normalizer = Util::AttributeNormalizer.new(attributes)
+        @id = normalizer.fetch(:id, :string, :limit => ID_MAX_BYTES)
+        @name = normalizer.fetch(:name, :string, :limit => NAME_MAX_BYTES)
+        @email = normalizer.fetch(:email, :string, :limit => EMAIL_MAX_BYTES)
+        @type = normalizer.fetch(:type, :string, :limit => TYPE_MAX_BYTES)
+        @meta = normalizer.fetch(:meta, :hash)
       end
 
       # Builds a hash representation containing simple objects, suitable for serialization (JSON).
+      def to_hash
+        @to_hash ||= Util::NonNilHashBuilder.build do |h|
+          h.add(:id, id)
+          h.add(:name, name)
+          h.add(:email, email)
+          h.add(:type, type)
+          h.add(:meta, meta)
+        end
+      end
+
       def as_json(_options = {})
-        {id: id, name: name, email: email, type: type, meta: meta}
+        to_hash
       end
     end
   end

data/lib/timber/events/controller_call.rb

@@ -8,22 +8,30 @@ module Timber
     #   Processing by PagesController#home as HTML
     #
     # @note This event should be installed automatically through integrations,
-    #   such as the {Integrations::ActionController::LogSubscriber} integration.
+    #   such as the {Integrations::ActionController} integration.
     class ControllerCall < Timber::Event
+      ACTION_MAX_BYTES = 256.freeze
+      FORMAT_MAX_BYTES = 256.freeze
+      CONTROLLER_MAX_BYTES = 256.freeze
       PARAMS_JSON_MAX_BYTES = 32_768.freeze
       PASSWORD_NAME = 'password'.freeze
 
       attr_reader :controller, :action, :params, :format
 
       def initialize(attributes)
-        @controller = attributes[:controller] || raise(ArgumentError.new(":controller is required"))
-        @action = attributes[:action] || raise(ArgumentError.new(":action is required"))
-        @params = sanitize_params(attributes[:params])
-        @format = attributes[:format]
+        normalizer = Util::AttributeNormalizer.new(attributes)
+        @controller = normalizer.fetch!(:controller, :string, :limit => CONTROLLER_MAX_BYTES)
+        @action = normalizer.fetch!(:action, :string, :limit => ACTION_MAX_BYTES)
+        @params = normalizer.fetch(:params, :hash, :sanitize => [PASSWORD_NAME])
+        @format = normalizer.fetch(:format, :string, :limit => FORMAT_MAX_BYTES)
       end
 
       def to_hash
-        {controller: controller, action: action, params_json: params_json}
+        @to_hash ||= Util::NonNilHashBuilder.build do |h|
+          h.add(:controller, controller)
+          h.add(:action, action)
+          h.add(:params_json, params.to_json.byteslice(0, PARAMS_JSON_MAX_BYTES))
+        end
       end
       alias to_h to_hash
 
@@ -42,24 +50,6 @@ module Timber
         end
         message
       end
-
-      private
-        def params_json
-          @params_json ||=
-            if params.nil? || params == {}
-              nil
-            else
-              params.to_json.byteslice(0, PARAMS_JSON_MAX_BYTES)
-            end
-        end
-
-        def sanitize_params(params)
-          if params.is_a?(::Hash)
-            Util::Hash.sanitize(params, [PASSWORD_NAME])
-          else
-            params
-          end
-        end
     end
   end
 end

data/lib/timber/events/custom.rb

@@ -23,12 +23,13 @@ module Timber
       # @option attributes [Hash] :data A hash of JSON encodable data to be stored with the
       #   log line.
       def initialize(attributes)
-        @type = attributes[:type] || raise(ArgumentError.new(":type is required"))
-        @message = attributes[:message] || raise(ArgumentError.new(":message is required"))
+        normalizer = Util::AttributeNormalizer.new(attributes)
+        @type = normalizer.fetch!(:type, :symbol)
+        @message = normalizer.fetch!(:message, :string)
 
-        data = attributes[:data]
+        data = normalizer.fetch!(:data, :hash)
 
-        if data.is_a?(Hash) && data[:time_ms].is_a?(Time)
+        if !data.nil? && data[:time_ms].is_a?(Time)
           data[:time_ms] = Timer.duration_ms(data[:time_ms])
           @message << " in #{data[:time_ms]}ms"
         end
@@ -37,7 +38,9 @@ module Timber
       end
 
       def to_hash
-        {Timber::Util::Object.try(type, :to_sym) => data}
+        @to_hash ||= Util::NonNilHashBuilder.build do |h|
+          h.add(type, data)
+        end
       end
       alias to_h to_hash