julewire-core 1.0.0 → 1.1.0

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)
@@ -154,7 +150,7 @@ module Julewire
 
         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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+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: 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 = 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 = 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 :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,
+                    compact_limits: false, freeze_values: false)
+            keys = KEYS.fetch(key_style)
+            limits = limits_hash(
+              keys,
+              max_array_items: max_array_items,
+              max_depth: max_depth,
+              max_hash_keys: max_hash_keys,
+              max_string_bytes: max_string_bytes,
+              compact_limits: compact_limits
+            )
+            metadata = {
+              keys.fetch(:truncated) => true,
+              keys.fetch(:truncated_fields) => field_list(fields),
+              keys.fetch(:limits) => limits
+            }
+            freeze_values ? deep_freeze(metadata, keys) : metadata
+          end
+
+          def append_field(fields, field)
+            fields ||= []
+            fields << field unless fields.include?(field)
+            fields
+          end
+
+          def valid?(value, max_fields: nil)
+            return false unless value.is_a?(Hash)
+
+            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
+
+          def field_list(fields)
+            Array(fields).uniq
+          end
+
+          def limits_hash(keys, max_array_items:, max_depth:, max_hash_keys:, max_string_bytes:, compact_limits:)
+            limits = {
+              keys.fetch(:max_array_items) => max_array_items,
+              keys.fetch(:max_depth) => max_depth,
+              keys.fetch(:max_hash_keys) => max_hash_keys,
+              keys.fetch(:max_string_bytes) => max_string_bytes
+            }
+            compact_limits ? limits.compact : limits
+          end
+
+          def deep_freeze(metadata, keys)
+            metadata.fetch(keys.fetch(:truncated_fields)).each(&:freeze)
+            metadata.fetch(keys.fetch(:truncated_fields)).freeze
+            metadata.fetch(keys.fetch(:limits)).freeze
+            metadata.freeze
+          end
+
+          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)
+
+              copied[target_keys.fetch(name)] = limits.fetch(source_key)
+            end
+          end
+
+          def metadata_keys(value)
+            return SYMBOL_METADATA_KEYS if exact_keys?(value, METADATA_KEYS)
+
+            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
+
+            fields.all?(String)
+          end
+
+          def valid_limits?(limits, limit_keys:)
+            return false unless limits.is_a?(Hash)
+
+            limits.all? do |key, value|
+              limit_keys.include?(key) && (value.nil? || value.instance_of?(Integer))
+            end
+          end
+        end
+      end
+      private_constant :TruncationMetadata
+    end
+  end
+end