julewire-core 1.0.0 → 1.1.0

data/lib/julewire/core/serialization/backtrace_limiter.rb

@@ -4,6 +4,9 @@ module Julewire
   module Core
     module Serialization
       class BacktraceLimiter
+        MAX_CAUSE_DEPTH = Core::NORMALIZATION_MAX_DEPTH
+        private_constant :MAX_CAUSE_DEPTH
+
         class << self
           def call(value, max_backtrace_lines:)
             new(max_backtrace_lines: max_backtrace_lines).call(value)
@@ -18,18 +21,18 @@ module Julewire
         end
 
         def call(value)
-          @seen = {}.compare_by_identity
-          limit_backtraces(value)
+          limit_backtraces(value, Set.new.compare_by_identity)
           value
-        ensure
-          @seen = nil
         end
 
         private
 
-        def limit_backtraces(value)
-          while value.is_a?(Hash) && !@seen.key?(value)
-            @seen[value] = true
+        def limit_backtraces(value, seen)
+          MAX_CAUSE_DEPTH.times do
+            break unless value.is_a?(Hash)
+            break if seen.include?(value)
+
+            seen.add(value)
             limit_backtrace_field!(value)
             value = value[:cause]
           end
@@ -40,8 +43,9 @@ module Julewire
 
           if @max_backtrace_lines.zero?
             error.delete(:backtrace)
-          elsif error[:backtrace].is_a?(Array)
-            error[:backtrace] = error[:backtrace].first(@max_backtrace_lines)
+          else
+            backtrace = error.fetch(:backtrace)
+            error[:backtrace] = backtrace.first(@max_backtrace_lines) if backtrace.is_a?(Array)
           end
         end
       end

data/lib/julewire/core/serialization/bounded_transform.rb

@@ -35,12 +35,11 @@ module Julewire
           @prepare_values = !@transform.nil?
           @track_paths = @prepare_values && !track_paths.equal?(false)
         end
+        private_class_method :new
 
         def call(value)
           @root = value
           walk(value)
-        ensure
-          @root = nil
         end
 
         private
@@ -49,6 +48,8 @@ module Julewire
           transformed = @transform.call(value, key: key, path: path, original: @root, depth: depth)
           transformed.equal?(CONTINUE) ? value : transformed
         end
+
+        def truncation_metadata(fields) = super(fields, key_style: :symbol)
       end
     end
   end

data/lib/julewire/core/serialization/bounded_traversal.rb

@@ -20,18 +20,17 @@ module Julewire
             max_array_items: DEFAULT_MAX_ARRAY_ITEMS,
             max_depth: DEFAULT_MAX_DEPTH,
             max_hash_keys: DEFAULT_MAX_HASH_KEYS,
-            max_string_bytes: DEFAULT_MAX_STRING_BYTES
+            max_string_bytes: DEFAULT_MAX_STRING_BYTES,
+            key_style: :string
           )
-            {
-              "truncated" => true,
-              "truncated_fields" => Array(fields).uniq,
-              "limits" => {
-                "max_array_items" => max_array_items,
-                "max_depth" => max_depth,
-                "max_hash_keys" => max_hash_keys,
-                "max_string_bytes" => max_string_bytes
-              }
-            }
+            TruncationMetadata.build(
+              fields,
+              key_style: key_style,
+              max_array_items: max_array_items,
+              max_depth: max_depth,
+              max_hash_keys: max_hash_keys,
+              max_string_bytes: max_string_bytes
+            )
           end
         end
 
@@ -43,57 +42,52 @@ module Julewire
           @max_hash_keys = Validation.validate_integer_limit!(max_hash_keys, name: :max_hash_keys)
           @max_string_bytes = Validation.validate_integer_limit!(max_string_bytes, name: :max_string_bytes)
           @truncation_key = truncation_key
-          @last_truncated = false
-          @compact_empty = false
-          @prepare_values = false
-          @track_paths = false
         end
 
         private
 
         def walk(value)
-          @last_truncated = false
           traverse(value) { |root, depth| walk_value(root, depth, nil, nil) }
         ensure
           @last_truncated = false
         end
 
         def walk_value(value, depth, key, path)
-          @last_truncated = false
           value = prepare_value(value, depth, key, path) if @prepare_values
-          return max_depth_value if depth >= @max_depth
+          return max_depth_value if depth == @max_depth
           return walk_container(value, depth, path) if value.is_a?(Array) || hash_like?(value)
 
-          scalar_value(value, depth, key, path)
+          scalar_value(value, depth)
         rescue StandardError => e
-          @last_truncated = false
           error_value(e)
         end
 
-        def prepare_value(value, _depth, _key, _path) = value
-
         def hash_like?(value) = value.is_a?(Hash)
 
-        def scalar_value(value, _depth, _key, _path)
-          value.is_a?(String) ? string_value(value) : clear_truncated(value)
+        def scalar_value(value, _depth)
+          value.is_a?(String) ? string_value(value) : value
         end
 
         # Transform-stage errors must bubble so processors can fail closed.
-        def error_value(error)
-          raise error
+        def error_value(_error)
+          raise
         end
 
         def walk_container(value, depth, path)
-          return circular_value if traversal_seen?(value)
+          seen = traversal_seen
+          return circular_value if seen.include?(value)
 
-          with_marked_traversal_container(value) do
+          seen.add(value)
+          begin
             value.is_a?(Array) ? walk_array(value, depth, path) : walk_hash(value, depth, path)
+          ensure
+            seen.delete(value)
           end
         end
 
         def circular_value
           @last_truncated = true
-          Core::CIRCULAR_REFERENCE
+          CIRCULAR_REFERENCE
         end
 
         def max_depth_value
@@ -101,7 +95,7 @@ module Julewire
         end
 
         def walk_hash(value, depth, path)
-          return walk_compact_hash(value, depth, path) if @compact_empty
+          return walk_compact_hash(value, depth) if @compact_empty
 
           walk_full_hash(value, depth, path)
         end
@@ -110,121 +104,122 @@ module Julewire
           fields = nil
           result = {}
           track_paths = @track_paths
+          visited = 0
           value.each do |raw_key, item|
-            if result.length >= @max_hash_keys
+            if visited == @max_hash_keys
               fields = append_truncation_field(fields, "hash_keys")
               break
             end
 
-            child = walk_value(item, depth + 1, raw_key, track_paths ? path_for(path, raw_key) : nil)
-            child_truncated = consume_truncated
+            visited += 1
+            child_path = path_for(path, raw_key) if track_paths
+            child = walk_value(item, depth + 1, raw_key, child_path)
             key = key_value(raw_key)
-            key_truncated = consume_truncated
             result[key] = child
-            fields = record_hash_truncation(fields, raw_key, key, key_truncated, child_truncated)
+            fields = record_hash_truncation(fields, key, consume_truncated)
           end
           finish_hash(result, fields)
         end
 
-        def walk_compact_hash(value, depth, path)
+        def walk_compact_hash(value, depth)
           fields = nil
           result = {}
-          track_paths = @track_paths
+          visited = 0
           value.each do |raw_key, item|
-            next if raw_omitted_value?(item)
-
-            child = walk_value(item, depth + 1, raw_key, track_paths ? path_for(path, raw_key) : nil)
-            child_truncated = consume_truncated
-            next if omitted_value?(child)
-
-            if result.length >= @max_hash_keys
+            # The hash cap bounds visited input entries, not final output keys, so
+            # serialized-key collisions and compacted entries cannot hide work.
+            if visited == @max_hash_keys
               fields = append_truncation_field(fields, "hash_keys")
               break
             end
 
+            visited += 1
+            next if raw_omitted_value?(item)
+
+            child = walk_value(item, depth + 1, nil, nil)
+            next if omitted_value?(child)
+
             key = key_value(raw_key)
-            key_truncated = consume_truncated
             result[key] = child
-            fields = record_hash_truncation(fields, raw_key, key, key_truncated, child_truncated)
+            fields = record_hash_truncation(fields, key, consume_truncated)
           end
           finish_hash(result, fields)
         end
 
         def walk_array(value, depth, path)
-          return walk_compact_array(value, depth, path) if @compact_empty
+          return walk_compact_array(value, depth) if @compact_empty
 
           walk_full_array(value, depth, path)
         end
 
         def walk_full_array(value, depth, path)
-          fields = nil
+          truncated = false
           result = []
+          visited = 0
           value.each do |item|
-            if result.length >= @max_array_items
-              fields = append_truncation_field(fields, "array_items")
+            if visited == @max_array_items
+              truncated = true
               break
             end
 
+            visited += 1
             child = walk_value(item, depth + 1, nil, path)
             child_truncated = consume_truncated
             result << child
-            fields = append_truncation_field(fields, "array_items") if child_truncated
+            truncated = true if child_truncated
           end
-          finish_array(result, fields)
+          finish_array(result, truncated && "array_items")
         end
 
-        def walk_compact_array(value, depth, path)
-          fields = nil
+        def walk_compact_array(value, depth)
+          truncated = false
           result = []
+          visited = 0
           value.each do |item|
+            if visited == @max_array_items
+              truncated = true
+              break
+            end
+
+            visited += 1
             next if raw_omitted_value?(item)
 
-            child = walk_value(item, depth + 1, nil, path)
+            child = walk_value(item, depth + 1, nil, nil)
             child_truncated = consume_truncated
             next if omitted_value?(child)
 
-            if result.length >= @max_array_items
-              fields = append_truncation_field(fields, "array_items")
-              break
-            end
-
             result << child
-            fields = append_truncation_field(fields, "array_items") if child_truncated
+            truncated = true if child_truncated
           end
-          finish_array(result, fields)
+          finish_array(result, truncated && "array_items")
         end
 
-        def omitted_value?(_value) = false
-
-        def raw_omitted_value?(_value) = false
-
-        def key_value(key)
-          clear_truncated(key.is_a?(String) ? copy_string(key) : key)
-        end
+        def key_value(key) = key
 
-        def record_hash_truncation(fields, raw_key, _key, _key_truncated, child_truncated)
-          return fields unless child_truncated
+        def record_hash_truncation(fields, key, truncated)
+          return fields unless truncated
 
-          append_truncation_field(fields, raw_key.to_s)
+          append_truncation_field(fields, key.to_s)
         end
 
         def finish_hash(result, fields)
-          return clear_truncated(result) unless fields
+          return result unless fields
 
           result[@truncation_key] = truncation_metadata(fields) if @truncation_key
           mark_truncated(result)
         end
 
         def finish_array(result, fields)
-          return clear_truncated(result) unless fields
+          return result unless fields
 
           result << { @truncation_key => truncation_metadata(fields) } if @truncation_key
           mark_truncated(result)
         end
 
-        def truncation_metadata(fields)
+        def truncation_metadata(fields, key_style: :string)
           self.class.truncation_metadata(
             fields,
+            key_style: key_style,
             max_array_items: @max_array_items,
             max_depth: @max_depth,
             max_hash_keys: @max_hash_keys,
@@ -233,7 +228,7 @@ module Julewire
         end
 
         def string_value(value)
-          return clear_truncated(copy_string(value)) if value.bytesize <= @max_string_bytes
+          return copy_string(value) if value.bytesize <= @max_string_bytes
 
           mark_truncated("#{value.byteslice(0, @max_string_bytes).scrub("?")}#{TRUNCATED_SUFFIX}")
         end
@@ -243,11 +238,6 @@ module Julewire
           value
         end
 
-        def clear_truncated(value)
-          @last_truncated = false
-          value
-        end
-
         def consume_truncated
           truncated = @last_truncated
           @last_truncated = false
@@ -259,8 +249,7 @@ module Julewire
         end
 
         def append_truncation_field(fields, field)
-          (fields ||= []) << field
-          fields
+          TruncationMetadata.append_field(fields, field)
         end
 
         def path_for(parent_path, key)

data/lib/julewire/core/serialization/deep_compact_empty.rb

@@ -27,23 +27,21 @@ module Julewire
         private
 
         def compact_value!(value)
-          return compact_hash!(value) if value.is_a?(Hash)
-          return compact_array!(value) if value.is_a?(Array)
-
-          value
+          if value.is_a?(Hash)
+            compact_hash!(value)
+          elsif value.is_a?(Array)
+            compact_array!(value)
+          else
+            value
+          end
         end
 
         def compact_hash!(value)
           with_traversal_container(value, value) do
             value.each do |key, item|
               compacted = compact_value!(item)
-              if self.class.omitted?(compacted)
-                value.delete(key)
-              elsif !compacted.equal?(item)
-                value[key] = compacted
-              end
+              value.delete(key) if self.class.omitted?(compacted)
             end
-            value
           end
         end
 
@@ -57,7 +55,7 @@ module Julewire
               value[index] = compacted
               index += 1
             end
-            value.slice!(index, value.length - index) if index < value.length
+            value.slice!(index, value.length)
             value
           end
         end

data/lib/julewire/core/serialization/deep_freeze.rb

@@ -7,9 +7,46 @@ module Julewire
         include ValueTraversal
 
         class << self
-          def call(value, max_depth: Core::NORMALIZATION_MAX_DEPTH, trust_frozen: false)
+          def call(value, max_depth: NORMALIZATION_MAX_DEPTH, trust_frozen: false, validate_symbol_keys: false)
+            validate_symbol_keys(value) if validate_symbol_keys
             new(max_depth, trust_frozen: trust_frozen).call(value)
           end
+
+          def validate_symbol_keys(value)
+            # WeakMap is identity-keyed and accepts new keys while enumerating,
+            # so reachable containers form one finite work inventory without a
+            # separate cycle-skip branch.
+            containers = ObjectSpace::WeakMap.new
+            containers[value] = nil if container?(value)
+            containers.each_key do |current|
+              if current.is_a?(Hash)
+                current.each do |key, item|
+                  validate_symbol_key!(key)
+                  containers[item] = nil if container?(item)
+                end
+              else
+                current.each { containers[it] = nil if container?(it) }
+              end
+            end
+            value
+          end
+
+          def validate_symbol_hash(value)
+            raise TypeError, "owned data must be a Hash" unless value.is_a?(Hash)
+
+            validate_symbol_keys(value)
+          end
+
+          private
+
+          def container?(value)
+            value.is_a?(Hash) || value.is_a?(Array)
+          end
+
+          def validate_symbol_key!(key)
+            raise TypeError, Fields::Internal::RECORD_STRING_KEY_ERROR if key.is_a?(String)
+            raise TypeError, Fields::Internal::RECORD_SYMBOL_KEY_ERROR unless key.instance_of?(Symbol)
+          end
         end
 
         def initialize(max_depth, trust_frozen:)
@@ -24,7 +61,7 @@ module Julewire
         private
 
         def freeze_value(value, depth)
-          return value.freeze if value.is_a?(String)
+          value.freeze if value.is_a?(String)
           return value if @trust_frozen && value.frozen?
           return freeze_container(value, depth) if value.is_a?(Hash) || value.is_a?(Array)
 
@@ -32,7 +69,7 @@ module Julewire
         end
 
         def freeze_container(value, depth)
-          return Serializer::MAX_DEPTH_VALUE.freeze if depth_limited?(depth)
+          return Serializer::MAX_DEPTH_VALUE if depth_limited?(depth)
 
           with_traversal_container(value, value) do
             value.is_a?(Hash) ? freeze_hash(value, depth) : freeze_array(value, depth)
@@ -40,11 +77,13 @@ module Julewire
         end
 
         def depth_limited?(depth)
-          @max_depth && depth >= @max_depth
+          depth == @max_depth
         end
 
         def freeze_hash(value, depth)
-          value.each { |key, item| freeze_child(value, key, item, depth) }
+          value.each do |key, item|
+            freeze_child(value, key, item, depth)
+          end
           value.freeze
         end
 
@@ -55,7 +94,7 @@ module Julewire
 
         def freeze_child(value, key, item, depth)
           frozen = freeze_value(item, depth + 1)
-          value[key] = frozen unless value.frozen? || frozen.equal?(item)
+          value[key] = frozen unless value.frozen?
         end
       end
     end

data/lib/julewire/core/serialization/encoding_sanitizer.rb

@@ -9,7 +9,6 @@ module Julewire
             raise TypeError, "value must be a String" unless value.is_a?(String)
 
             return value if valid_utf8?(value) || valid_ascii_only?(value)
-            return value.scrub("?") if utf8?(value)
 
             encode_utf8(value)
           rescue EncodingError
@@ -23,7 +22,7 @@ module Julewire
           end
 
           def valid_ascii_only?(value)
-            value.ascii_only? && value.valid_encoding?
+            value.ascii_only?
           end
 
           def utf8?(value)
@@ -31,7 +30,7 @@ module Julewire
           end
 
           def encode_utf8(value)
-            value.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "?")
+            value.encode(Encoding::UTF_8, invalid: :replace, replace: "?")
           end
         end
       end

data/lib/julewire/core/serialization/exception_shape.rb

@@ -9,7 +9,7 @@ module Julewire
         DEFAULT_MAX_CAUSE_DEPTH = 5
 
         class << self
-          def call(error, max_backtrace_lines: Core::MAX_BACKTRACE_LINES, max_cause_depth: DEFAULT_MAX_CAUSE_DEPTH)
+          def call(error, max_backtrace_lines: MAX_BACKTRACE_LINES, max_cause_depth: DEFAULT_MAX_CAUSE_DEPTH)
             new(
               max_backtrace_lines: max_backtrace_lines,
               max_cause_depth: max_cause_depth
@@ -32,7 +32,7 @@ module Julewire
         def shape_exception(error, depth)
           return error unless error.is_a?(Exception)
 
-          with_traversal_container(error, Core::CIRCULAR_REFERENCE) do
+          with_traversal_container(error, CIRCULAR_REFERENCE) do
             exception_hash(error, depth)
           end
         end
@@ -50,7 +50,7 @@ module Julewire
             cause = exception_cause(error)
             next unless cause
 
-            if depth >= @max_cause_depth
+            if depth == @max_cause_depth
               result[:cause_truncated] = true
             else
               result[:cause] = shape_exception(cause, depth + 1)
@@ -59,20 +59,21 @@ module Julewire
         end
 
         def class_name(error)
-          error.class.name || error.class.to_s
+          error.class.to_s
         rescue StandardError
           "Exception"
         end
 
         def error_message(error)
           message = error.message
-          message.is_a?(String) ? message.dup : message.to_s
+          message.instance_of?(String) ? message.dup : message.to_s
         rescue StandardError
           "[Unavailable]"
         end
 
         def backtrace(error)
-          @backtrace_limiter.call(backtrace: Core::Fields::FieldSet.deep_dup(error.backtrace))[:backtrace]
+          limited = @backtrace_limiter.call(backtrace: Fields::FieldSet.deep_dup(error.backtrace))
+          limited.fetch(:backtrace)
         rescue StandardError
           nil
         end

data/lib/julewire/core/serialization/json_encoder.rb

@@ -13,7 +13,7 @@ module Julewire
           max_array_items: Serializer::DEFAULT_MAX_ARRAY_ITEMS,
           max_hash_keys: Serializer::DEFAULT_MAX_HASH_KEYS,
           compact_empty: true,
-          max_backtrace_lines: Core::MAX_BACKTRACE_LINES,
+          max_backtrace_lines: MAX_BACKTRACE_LINES,
           append_newline: true
         )
           @max_depth = max_depth
@@ -23,6 +23,7 @@ module Julewire
           @compact_empty = compact_empty
           @max_backtrace_lines = max_backtrace_lines
           @line_suffix = append_newline ? "\n" : ""
+          # `append_newline` is suffix-only; it does not change serializer shape.
           @serializer_key = [
             @max_depth,
             @max_string_bytes,
@@ -30,11 +31,11 @@ module Julewire
             @max_hash_keys,
             @compact_empty,
             @max_backtrace_lines
-          ].freeze
+          ]
         end
 
         def call(payload)
-          JSON.generate(serialized_payload(payload), allow_nan: false).tap do |json|
+          JSON.generate(serialized_payload(payload)).tap do |json|
             json << @line_suffix
           end
         end
@@ -42,14 +43,11 @@ module Julewire
         private
 
         def serialized_payload(payload)
-          serializer = cached_serializer
-          return build_serializer.serialize(payload) if serializer.in_use?
-
-          serializer.serialize(payload)
-        end
-
-        def cached_serializer
-          SerializerPool.serializer(:julewire_core_json_encoder_serializers, @serializer_key) { build_serializer }
+          SerializerPool.serialize(
+            :julewire_core_json_encoder_serializers,
+            @serializer_key,
+            payload
+          ) { build_serializer }
         end
 
         def build_serializer
@@ -59,8 +57,7 @@ module Julewire
             max_array_items: @max_array_items,
             max_hash_keys: @max_hash_keys,
             compact_empty: @compact_empty,
-            max_backtrace_lines: @max_backtrace_lines,
-            copy_strings: false
+            max_backtrace_lines: @max_backtrace_lines
           )
         end
       end