julewire-core 1.0.1 → 1.1.1

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

@@ -28,7 +28,7 @@ module Julewire
             max_array_items: DEFAULT_MAX_ARRAY_ITEMS,
             max_hash_keys: DEFAULT_MAX_HASH_KEYS,
             compact_empty: false,
-            max_backtrace_lines: Core::MAX_BACKTRACE_LINES
+            max_backtrace_lines: MAX_BACKTRACE_LINES
           )
             new(
               max_depth: max_depth,
@@ -47,8 +47,7 @@ module Julewire
           max_array_items: DEFAULT_MAX_ARRAY_ITEMS,
           max_hash_keys: DEFAULT_MAX_HASH_KEYS,
           compact_empty: false,
-          max_backtrace_lines: Core::MAX_BACKTRACE_LINES,
-          copy_strings: true
+          max_backtrace_lines: MAX_BACKTRACE_LINES
         )
           super(
             max_array_items: max_array_items,
@@ -63,7 +62,6 @@ module Julewire
             name: :max_backtrace_lines
           )
           @compact_empty = compact_empty
-          @copy_strings = copy_strings
         end
 
         def serialize(value)
@@ -77,27 +75,25 @@ module Julewire
 
         private
 
-        def scalar_value(value, depth, _key, _path)
+        def scalar_value(value, depth)
           return serialize_exception(value, depth) if value.is_a?(Exception)
 
           case value
           when nil, true, false
-            clear_truncated(value)
+            value
           when Numeric
             serialize_numeric(value)
           when Symbol
-            clear_truncated(value.to_s)
+            value.to_s
           when String
             serialize_string(value)
-          when Time, DateTime, Date
+          when Time, Date
             serialize_temporal(value)
           else
             return serialize_iso8601_temporal(value) if zone_temporal?(value)
 
             serialize_object(value)
           end
-        rescue StandardError => e
-          clear_truncated(unserializable_marker(e))
         end
 
         def serialize_exception(error, depth)
@@ -116,30 +112,30 @@ module Julewire
         end
 
         def serialize_numeric(value)
-          return serialize_float(value) if value.is_a?(Float)
-          return clear_truncated(value) if value.is_a?(Integer)
-          return serialize_string(value.to_s("F")) if defined?(BigDecimal) && value.is_a?(BigDecimal)
+          return serialize_float(value) if value.instance_of?(Float)
+          return value if value.instance_of?(Integer)
+          return serialize_string(value.to_s("F")) if defined?(BigDecimal) && value.instance_of?(::BigDecimal)
 
-          serialize_string(EncodingSanitizer.call(value.to_s))
+          serialize_string(value.to_s)
         end
 
         def serialize_float(value)
-          return clear_truncated(value) if value.finite?
-          return clear_truncated(NAN_VALUE) if value.nan?
+          return value if value.finite?
+          return NAN_VALUE if value.nan?
 
-          clear_truncated(value.positive? ? INFINITY_VALUE : NEGATIVE_INFINITY_VALUE)
+          value.positive? ? INFINITY_VALUE : NEGATIVE_INFINITY_VALUE
         end
 
         def serialize_temporal(value)
-          return clear_truncated(value.getutc.iso8601(9)) if value.is_a?(Time)
-          return clear_truncated(value.iso8601(9)) if value.is_a?(DateTime)
+          return value.getutc.iso8601(9) if value.is_a?(Time)
+          return value.iso8601(9) if value.is_a?(DateTime)
 
-          clear_truncated(value.iso8601)
+          value.iso8601
         end
 
         def serialize_iso8601_temporal(value)
           temporal = value.respond_to?(:utc) ? value.utc : value
-          clear_truncated(EncodingSanitizer.call(temporal.iso8601(9)))
+          EncodingSanitizer.call(temporal.iso8601(9))
         end
 
         def zone_temporal?(value)
@@ -152,9 +148,9 @@ module Julewire
 
         def raw_omitted_value?(value) = DeepCompactEmpty.omitted?(value)
 
-        def key_value(key, _depth = nil, _path = nil) = serialize_key(key)
+        def key_value(key) = serialize_key(key)
 
-        def error_value(error) = clear_truncated(unserializable_marker(error))
+        def error_value(error) = unserializable_marker(error)
 
         def serialize_key(key)
           case key
@@ -170,31 +166,18 @@ module Julewire
         end
 
         def serialize_symbol_key(key)
-          name = key.name
-          return serialize_trusted_key_string(name) if safe_trusted_key_name?(name)
-
-          serialize_key_string(name)
-        end
-
-        def safe_trusted_key_name?(value)
-          value.ascii_only? || (value.encoding == Encoding::UTF_8 && value.valid_encoding?)
+          serialize_key_string(key.name)
         end
 
         def serialize_key_string(value)
           string = EncodingSanitizer.call(value)
-          return clear_truncated(copy_string(string)) if string.bytesize <= MAX_KEY_BYTES
+          return copy_string(string) if string.bytesize <= MAX_KEY_BYTES
 
           mark_truncated("#{string.byteslice(0, MAX_KEY_BYTES).scrub("?")}#{TRUNCATED_SUFFIX}")
         end
 
-        def serialize_trusted_key_string(value)
-          return clear_truncated(value) if value.bytesize <= MAX_KEY_BYTES
-
-          mark_truncated("#{value.byteslice(0, MAX_KEY_BYTES).scrub("?")}#{TRUNCATED_SUFFIX}")
-        end
-
         def serialize_object(value)
-          clear_truncated(object_marker(value))
+          object_marker(value)
         end
 
         def object_marker(value)
@@ -213,20 +196,10 @@ module Julewire
 
         def serialize_string(value)
           string = EncodingSanitizer.call(value)
-          return clear_truncated(copy_string(string)) if string.bytesize <= @max_string_bytes
+          return copy_string(string) if string.bytesize <= @max_string_bytes
 
           mark_truncated("#{string.byteslice(0, @max_string_bytes).scrub("?")}#{TRUNCATED_SUFFIX}")
         end
-
-        def copy_string(value)
-          value.frozen? || !@copy_strings ? value : value.dup
-        end
-
-        def record_hash_truncation(fields, _raw_key, key, key_truncated, child_truncated)
-          return fields unless key_truncated || child_truncated
-
-          append_truncation_field(fields, key)
-        end
       end
     end
   end

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

@@ -14,6 +14,15 @@ module Julewire
             end
             pool[serializer_key] ||= yield
           end
+
+          def serialize(pool_key, serializer_key, payload, &)
+            serialize_with(serializer(pool_key, serializer_key, &), payload, &)
+          end
+
+          def serialize_with(serializer, payload)
+            serializer = yield if serializer.in_use?
+            serializer.serialize(payload)
+          end
         end
       end
     end

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

@@ -48,13 +48,13 @@ module Julewire
             positive: true
           )
           @color = color
-          @line_suffix = append_newline ? "\n" : ""
+          @append_newline = append_newline
           @theme = validate_theme(theme)
         end
 
         def call(payload)
           text = payload.is_a?(String) ? payload : line_for(payload)
-          "#{text}#{@line_suffix}"
+          @append_newline ? "#{text}\n" : text
         end
 
         private
@@ -82,7 +82,7 @@ module Julewire
           # Console output is human-facing; JSON keeps nanosecond precision.
           return value.iso8601(6) if value.respond_to?(:iso8601)
 
-          value.to_s
+          value
         end
 
         def severity(payload)
@@ -123,7 +123,7 @@ module Julewire
         def compact_hash(name, value)
           return unless value.is_a?(Hash) && !value.empty?
 
-          "#{name}=#{truncate(JSON.generate(value, allow_nan: false))}"
+          "#{name}=#{truncate(JSON.generate(value))}"
         rescue StandardError
           "#{name}=#{truncate(value.inspect)}"
         end
@@ -135,7 +135,7 @@ module Julewire
         end
 
         def value_at(payload, key)
-          Fields::Lookup.value(payload, key)
+          Fields::Lookup.wire_value(payload, key)
         end
 
         def blank?(value)

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

@@ -4,39 +4,41 @@ module Julewire
   module Core
     module Serialization
       module TruncationMetadata
+        NAMES = %i[truncated truncated_fields limits max_array_items max_depth max_hash_keys max_string_bytes].freeze
         KEYS = {
-          string: {
-            truncated: "truncated",
-            truncated_fields: "truncated_fields",
-            limits: "limits",
-            max_array_items: "max_array_items",
-            max_depth: "max_depth",
-            max_hash_keys: "max_hash_keys",
-            max_string_bytes: "max_string_bytes"
-          }.freeze,
-          symbol: {
-            truncated: :truncated,
-            truncated_fields: :truncated_fields,
-            limits: :limits,
-            max_array_items: :max_array_items,
-            max_depth: :max_depth,
-            max_hash_keys: :max_hash_keys,
-            max_string_bytes: :max_string_bytes
-          }.freeze
+          string: NAMES.to_h { [it, it.to_s] }.freeze,
+          symbol: NAMES.to_h { [it, it] }.freeze
         }.freeze
         METADATA_KEYS = KEYS.fetch(:symbol).values_at(:truncated, :truncated_fields, :limits).freeze
-        METADATA_KEY_NAMES = METADATA_KEYS.map(&:to_s).freeze
+        METADATA_KEY_NAMES = KEYS.fetch(:string).values_at(:truncated, :truncated_fields, :limits).freeze
         LIMIT_KEYS = KEYS.fetch(:symbol).values_at(
           :max_array_items,
           :max_depth,
           :max_hash_keys,
           :max_string_bytes
         ).freeze
-        LIMIT_KEY_NAMES = LIMIT_KEYS.map(&:to_s).freeze
-        [KEYS, METADATA_KEYS, METADATA_KEY_NAMES, LIMIT_KEYS, LIMIT_KEY_NAMES].each do |constant|
+        LIMIT_KEY_NAMES = KEYS.fetch(:string).values_at(
+          :max_array_items,
+          :max_depth,
+          :max_hash_keys,
+          :max_string_bytes
+        ).freeze
+        SYMBOL_METADATA_KEYS = KEYS.fetch(:symbol).merge(limit_keys: LIMIT_KEYS).freeze
+        STRING_METADATA_KEYS = KEYS.fetch(:string).merge(limit_keys: LIMIT_KEY_NAMES).freeze
+        [
+          NAMES,
+          KEYS,
+          METADATA_KEYS,
+          METADATA_KEY_NAMES,
+          LIMIT_KEYS,
+          LIMIT_KEY_NAMES,
+          SYMBOL_METADATA_KEYS,
+          STRING_METADATA_KEYS
+        ].each do |constant|
           ::Ractor.make_shareable(constant) if defined?(::Ractor) && ::Ractor.respond_to?(:make_shareable)
         end
-        private_constant :KEYS, :METADATA_KEYS, :METADATA_KEY_NAMES, :LIMIT_KEYS, :LIMIT_KEY_NAMES
+        private_constant :NAMES, :KEYS, :METADATA_KEYS, :METADATA_KEY_NAMES, :LIMIT_KEYS, :LIMIT_KEY_NAMES,
+                         :SYMBOL_METADATA_KEYS, :STRING_METADATA_KEYS
 
         class << self
           def build(fields, max_array_items:, max_depth:, max_hash_keys:, max_string_bytes:, key_style: :string,
@@ -66,12 +68,25 @@ module Julewire
 
           def valid?(value, max_fields: nil)
             return false unless value.is_a?(Hash)
-            return false unless valid_top_level_keys?(value)
-            return false unless fetch_key(value, :truncated) == true
 
-            fields = fetch_key(value, :truncated_fields)
-            limits = fetch_key(value, :limits)
-            valid_fields?(fields, max_fields: max_fields) && valid_limits?(limits)
+            keys = metadata_keys(value)
+            return false unless keys
+            return false unless value.fetch(keys.fetch(:truncated)) == true
+
+            valid_fields?(value.fetch(keys.fetch(:truncated_fields)), max_fields: max_fields) &&
+              valid_limits?(value.fetch(keys.fetch(:limits)), limit_keys: keys.fetch(:limit_keys))
+          end
+
+          def copy(value, freeze_values:, key_style: :symbol)
+            source_keys = metadata_keys(value)
+            target_keys = KEYS.fetch(key_style)
+            metadata = {
+              target_keys.fetch(:truncated) => true,
+              target_keys.fetch(:truncated_fields) => copy_fields(value.fetch(source_keys.fetch(:truncated_fields))),
+              target_keys.fetch(:limits) => copy_limits(value.fetch(source_keys.fetch(:limits)), source_keys,
+                                                        target_keys)
+            }
+            freeze_values ? deep_freeze(metadata, target_keys) : metadata
           end
 
           private
@@ -97,43 +112,43 @@ module Julewire
             metadata.freeze
           end
 
-          def fetch_key(value, key)
-            return value[key] if value.key?(key)
+          def copy_fields(fields)
+            fields.map(&:dup)
+          end
+
+          def copy_limits(limits, source_keys, target_keys)
+            LIMIT_KEYS.each_with_object({}) do |name, copied|
+              source_key = source_keys.fetch(name)
+              next unless limits.key?(source_key)
 
-            value[key.to_s]
+              copied[target_keys.fetch(name)] = limits.fetch(source_key)
+            end
           end
 
-          def valid_top_level_keys?(value)
-            return false if value.length > METADATA_KEYS.length * 2
+          def metadata_keys(value)
+            return SYMBOL_METADATA_KEYS if exact_keys?(value, METADATA_KEYS)
 
-            value.keys.all? { known_key?(it, METADATA_KEYS, METADATA_KEY_NAMES) } &&
-              METADATA_KEYS.all? { value.key?(it) || value.key?(it.to_s) }
+            STRING_METADATA_KEYS if exact_keys?(value, METADATA_KEY_NAMES)
+          end
+
+          def exact_keys?(value, keys)
+            value.length == keys.length && keys.all? { value.key?(it) }
           end
 
           def valid_fields?(fields, max_fields:)
             return false unless fields.is_a?(Array)
+            return false if max_fields && fields.length > max_fields
 
-            seen = 0
-            fields.each do |field|
-              seen += 1
-              return false if max_fields && seen > max_fields
-              return false unless field.is_a?(String) || field.is_a?(Symbol)
-            end
-            true
+            fields.all?(String)
           end
 
-          def valid_limits?(limits)
+          def valid_limits?(limits, limit_keys:)
             return false unless limits.is_a?(Hash)
-            return false if limits.length > LIMIT_KEYS.length * 2
 
             limits.all? do |key, value|
-              known_key?(key, LIMIT_KEYS, LIMIT_KEY_NAMES) && (value.nil? || value.is_a?(Integer))
+              limit_keys.include?(key) && (value.nil? || value.instance_of?(Integer))
             end
           end
-
-          def known_key?(key, symbol_keys, string_keys)
-            symbol_keys.include?(key) || string_keys.include?(key)
-          end
         end
       end
       private_constant :TruncationMetadata