julewire-core 1.0.0 → 1.1.0

data/lib/julewire/core/facade_methods.rb

@@ -2,54 +2,94 @@
 
 module Julewire
   module Core
+    module FacadePrivateMethods
+      private
+
+      def punk_banner
+        "!!JULEWIRE PUNK!! chaos containment armed\n"
+      end
+
+      def punk_chaos_output(output, chaos)
+        options = chaos if chaos.is_a?(Hash)
+        Destinations::ChaosOutput.new(output, **options)
+      end
+
+      def emit_with_severity(severity, record, fields, &)
+        if !block_given? && !record.is_a?(Hash)
+          # Scalar eager logs stay allocation-light; lazy inputs need the wrapper
+          # so block-built records can still receive the eager severity.
+          emit(eager_severity_input(severity, record, fields))
+        else
+          emit(Records::LazyEmitInput.with_severity(severity, Core.emit_input(record, fields)), &)
+        end
+      end
+
+      def eager_severity_input(severity, record, fields)
+        input = if record.equal?(UNSET)
+                  fields
+                elsif fields.empty?
+                  { message: record.to_s }
+                else
+                  Core.emit_input(record, fields)
+                end
+        input.delete("severity")
+        input[:severity] = severity
+        input
+      end
+
+      def with_cleared_configure_guard
+        previous_guard = Fiber[Runtime::CONFIGURE_GUARD_KEY]
+        Fiber[Runtime::CONFIGURE_GUARD_KEY] = nil
+        yield
+      ensure
+        Fiber[Runtime::CONFIGURE_GUARD_KEY] = previous_guard
+      end
+    end
+
     module FacadeMethods
+      include FacadePrivateMethods
+
       def runtime(name = :default)
-        Core::RuntimeRegistry.fetch(name, current: Core::RuntimeLocator.current)
+        RuntimeRegistry.fetch(name)
       end
 
       def config = runtime.config
-
       def configure(&) = runtime.configure(&)
-
       def context = runtime.context
-
       def attributes = runtime.attributes
-
       def carry = runtime.carry
-
       def current_execution = runtime.current_execution
-
       def current_execution? = runtime.current_execution?
 
-      def emit(record = Core::UNSET, **fields, &)
+      def emit(record = UNSET, **fields, &)
         runtime.emit(record, **fields, &)
       end
 
-      def debug(record = Core::UNSET, **fields, &)
+      def debug(record = UNSET, **fields, &)
         emit_with_severity(:debug, record, fields, &)
       end
 
-      def info(record = Core::UNSET, **fields, &)
+      def info(record = UNSET, **fields, &)
         emit_with_severity(:info, record, fields, &)
       end
 
-      def warn(record = Core::UNSET, **fields, &)
+      def warn(record = UNSET, **fields, &)
         emit_with_severity(:warn, record, fields, &)
       end
 
-      def error(record = Core::UNSET, **fields, &)
+      def error(record = UNSET, **fields, &)
         emit_with_severity(:error, record, fields, &)
       end
 
-      def fatal(record = Core::UNSET, **fields, &)
+      def fatal(record = UNSET, **fields, &)
         emit_with_severity(:fatal, record, fields, &)
       end
 
-      def unknown(record = Core::UNSET, **fields, &)
+      def unknown(record = UNSET, **fields, &)
         emit_with_severity(:unknown, record, fields, &)
       end
 
-      def flush(timeout: Core::UNSET)
+      def flush(timeout: UNSET)
         runtime.flush(timeout: timeout)
       end
 
@@ -62,26 +102,26 @@ module Julewire
       def measure_start(key) = summary.measure_start(key)
 
       def doctor(name = :default)
-        Core::Diagnostics::Doctor.call(runtime(name))
+        Diagnostics::Doctor.call(runtime(name))
       end
 
       def tail(name = :default, **)
-        Core::Diagnostics::Tail.attach!(runtime(name), **)
+        Diagnostics::Tail.attach!(runtime(name), **)
       end
 
       def observe_self!(name = :default, **)
-        Core::Diagnostics::MetaObserver.attach!(name, **)
+        Diagnostics::MetaObserver.attach!(name, **)
       end
 
-      def dev!(name = :default, output: $stdout, color: Core::UNSET, chaos: false, banner: chaos, tail: true)
-        color = output.respond_to?(:tty?) ? output.tty? : true if color.equal?(Core::UNSET)
+      def dev!(name = :default, output: $stdout, color: UNSET, chaos: false, banner: chaos, tail: true)
+        color = output.respond_to?(:tty?) ? output.tty? : true if color.equal?(UNSET)
         punk!(name, output: output, color: color, chaos: chaos, banner: banner)
         return unless tail
 
         tail_options = tail == true ? {} : tail
         raise ArgumentError, "tail must be true, false, or an options Hash" unless tail_options.is_a?(Hash)
 
-        Core::Diagnostics::Tail.attach!(runtime(name), **tail_options)
+        Tail.attach!(runtime(name), **tail_options)
       end
 
       def punk!(name = :default, output: $stdout, color: true, chaos: false, banner: chaos)
@@ -102,21 +142,19 @@ module Julewire
       def fiber(**, &)
         raise ArgumentError, "block required" unless block_given?
 
-        envelope = Core::Propagation.capture_local
+        envelope = Propagation.capture_local
         Fiber.new(**) do |*args|
           with_cleared_configure_guard do
-            Core::Propagation.restore(envelope) { yield(*args) }
+            Propagation.restore(envelope, owned: true) { yield(*args) }
           end
         end
       end
 
       def labels = runtime.labels
-
       def after_fork! = runtime.after_fork!
+      def reset! = runtime.reset_facade!
 
-      def reset! = runtime.reset!
-
-      def close(timeout: Core::UNSET)
+      def close(timeout: UNSET)
         runtime.close(timeout: timeout)
       end
 
@@ -129,10 +167,10 @@ module Julewire
       def thread(*, &)
         raise ArgumentError, "block required" unless block_given?
 
-        envelope = Core::Propagation.capture_local
+        envelope = Propagation.capture_local
         Thread.new(*) do |*thread_args|
           with_cleared_configure_guard do
-            Core::Propagation.restore(envelope) { yield(*thread_args) }
+            Propagation.restore(envelope, owned: true) { yield(*thread_args) }
           end
         end
       end
@@ -140,42 +178,6 @@ module Julewire
       def with_execution(type:, **, &)
         runtime.with_execution(type: type, **, &)
       end
-
-      private
-
-      def punk_banner
-        "!!JULEWIRE PUNK!! chaos containment armed\n"
-      end
-
-      def punk_chaos_output(output, chaos)
-        options = chaos.is_a?(Hash) ? chaos : {}
-        Core::Destinations::ChaosOutput.new(output, **options)
-      end
-
-      def emit_with_severity(severity, record, fields, &)
-        if record.equal?(Core::UNSET)
-          fields.delete("severity")
-          fields[:severity] = severity
-          runtime.emit(fields, &)
-        elsif !block_given? && !record.is_a?(Hash)
-          # Scalar eager logs stay allocation-light; lazy inputs need the wrapper
-          # so block-built records can still receive the eager severity.
-          input = fields.empty? ? { message: record.to_s } : Core.emit_input(record, fields)
-          input.delete("severity")
-          input[:severity] = severity
-          runtime.emit(input)
-        else
-          runtime.emit(Core::Records::LazyEmitInput.with_severity(severity, Core.emit_input(record, fields)), &)
-        end
-      end
-
-      def with_cleared_configure_guard
-        previous_guard = Fiber[Core::Runtime::CONFIGURE_GUARD_KEY]
-        Fiber[Core::Runtime::CONFIGURE_GUARD_KEY] = nil
-        yield
-      ensure
-        Fiber[Core::Runtime::CONFIGURE_GUARD_KEY] = previous_guard
-      end
     end
   end
 end

data/lib/julewire/core/fields/attribute_keys.rb

@@ -45,8 +45,6 @@ module Julewire
 
             fields.compact
           end
-
-          def from(neutral) = neutral.is_a?(Hash) ? neutral : {}
         end
       end
     end

data/lib/julewire/core/fields/bags.rb

@@ -26,35 +26,31 @@ module Julewire
           source
         ].freeze
 
-        class << self
-          private
-
-          def define(name, **capabilities)
-            Definition.new(
-              name: name,
-              record_hash: true,
-              transform_container: true,
-              app_write: false,
-              integration_write: false,
-              propagate: false,
-              emit_by_default: true,
-              delete_paths: false,
-              stack: false,
-              **capabilities
-            )
-          end
+        definition = lambda do |name, **capabilities|
+          Definition.new(
+            name: name,
+            record_hash: true,
+            transform_container: true,
+            app_write: false,
+            integration_write: false,
+            propagate: false,
+            emit_by_default: true,
+            delete_paths: false,
+            stack: false,
+            **capabilities
+          )
         end
 
         DEFINITIONS = {
-          execution: define(:execution, integration_write: true, propagate: true),
-          context: define(
+          execution: definition.call(:execution, integration_write: true, propagate: true),
+          context: definition.call(
             :context,
             app_write: true,
             integration_write: true,
             propagate: true,
             stack: true
           ),
-          carry: define(
+          carry: definition.call(
             :carry,
             app_write: true,
             integration_write: true,
@@ -63,18 +59,18 @@ module Julewire
             delete_paths: true,
             stack: true
           ),
-          neutral: define(:neutral, integration_write: true, emit_by_default: false, stack: true),
-          attributes: define(
+          neutral: definition.call(:neutral, integration_write: true, emit_by_default: false, stack: true),
+          attributes: definition.call(
             :attributes,
             app_write: true,
             integration_write: true,
             stack: true
           ),
-          labels: define(:labels),
-          payload: define(:payload),
-          metrics: define(:metrics),
-          error: define(:error, record_hash: false),
-          summary: define(
+          labels: definition.call(:labels),
+          payload: definition.call(:payload),
+          metrics: definition.call(:metrics),
+          error: definition.call(:error, record_hash: false),
+          summary: definition.call(
             :summary,
             record_hash: false,
             transform_container: false,

data/lib/julewire/core/fields/field_set.rb

@@ -5,16 +5,22 @@ module Julewire
     module Fields
       # @api integration_spi
       module FieldSet
+        Serializer = Serialization::Serializer
+        TRUNCATION_METADATA_KEY = Serializer::TRUNCATION_METADATA_KEY.to_sym
+        RESERVED_TRUNCATION_METADATA_ERROR =
+          "#{Serializer::TRUNCATION_METADATA_KEY} is reserved for Julewire truncation metadata".freeze
+        INVALID_MODES = %i[ignore raise wrap].freeze
         VALUE_KEY = :value
+        private_constant :Serializer, :TRUNCATION_METADATA_KEY, :RESERVED_TRUNCATION_METADATA_ERROR, :INVALID_MODES
 
         class << self
           # Public ingress accepts String or Symbol keys. Core stores Symbol keys
           # after normalization so extension contracts stay simple.
-          def coerce(fields = nil, keyword_fields = {}, invalid: :ignore)
+          def coerce(fields = nil, keyword_fields = nil, invalid: :ignore)
+            validate_invalid_mode!(invalid)
             coerced = {}
             coerce_fields!(coerced, fields, invalid: invalid) unless fields.nil?
-            merge!(coerced, keyword_fields) unless keyword_fields.empty?
-            coerced
+            merge!(coerced, keyword_fields)
           end
 
           def merge(left, right)
@@ -25,51 +31,81 @@ module Julewire
             return target unless fields.is_a?(Hash)
 
             fields.each do |key, value|
-              target[Fields::Internal.normalize_key(key)] = copy_field_value(value)
+              target[normalized_field_key(key)] = copy_field_value(value)
             end
 
             target
           end
 
           def deep_dup(value)
-            return {} if value.is_a?(Hash) && value.empty?
-            return [] if value.is_a?(Array) && value.empty?
+            deep_dup_with(value, preserve_truncation_metadata: false)
+          end
 
-            Serialization::ValueCopy.call(value)
+          def deep_dup_owned(value)
+            deep_dup_with(value, preserve_truncation_metadata: true)
           end
 
           def deep_symbolize_keys(value)
-            return {} if value.is_a?(Hash) && value.empty?
-            return [] if value.is_a?(Array) && value.empty?
+            deep_symbolize_keys_with(value, preserve_truncation_metadata: false)
+          end
 
-            Serialization::ValueCopy.call(value, symbolize_keys: true)
+          def deep_symbolize_owned_keys(value)
+            deep_symbolize_keys_with(value, preserve_truncation_metadata: true)
           end
 
           def frozen_copy(value)
-            Fields::Internal.frozen_copy(value)
+            Internal.frozen_copy(value)
           end
 
           def value_for(hash, key, default: nil)
             return default unless hash.is_a?(Hash)
 
-            normalized = key.is_a?(String) ? Fields::Internal.normalize_key(key) : key
-            return hash[normalized] if hash.key?(normalized)
-
-            default
+            hash.fetch(Internal.normalize_key(key), default)
           end
 
           private
 
+          def deep_dup_with(value, preserve_truncation_metadata:)
+            Serialization::ValueCopy.call(
+              value,
+              preserve_truncation_metadata: preserve_truncation_metadata
+            )
+          end
+
+          def deep_symbolize_keys_with(value, preserve_truncation_metadata:)
+            Serialization::ValueCopy.call(
+              value,
+              max_array_items: Serializer::DEFAULT_MAX_ARRAY_ITEMS,
+              max_hash_keys: Serializer::DEFAULT_MAX_HASH_KEYS,
+              max_string_bytes: Serializer::DEFAULT_MAX_STRING_BYTES,
+              preserve_truncation_metadata: preserve_truncation_metadata,
+              symbolize_keys: true
+            )
+          end
+
           def coerce_fields!(target, fields, invalid:)
             if fields.is_a?(Hash)
               merge!(target, fields)
             elsif invalid == :wrap
-              target[VALUE_KEY] = deep_dup(fields)
+              target[VALUE_KEY] = copy_field_value(fields)
             elsif invalid == :raise
               raise ArgumentError, "fields must be a Hash"
             end
           end
 
+          def validate_invalid_mode!(invalid)
+            return if INVALID_MODES.include?(invalid)
+
+            raise ArgumentError, "invalid field coercion mode: #{invalid.inspect}"
+          end
+
+          def normalized_field_key(key)
+            normalized_key = Internal.normalize_key(key)
+            raise ArgumentError, RESERVED_TRUNCATION_METADATA_ERROR if normalized_key == TRUNCATION_METADATA_KEY
+
+            normalized_key
+          end
+
           def copy_field_value(value) = deep_symbolize_keys(value)
         end
       end