julewire-core 1.0.1 → 1.1.1

data/lib/julewire/core/execution/scope.rb

@@ -4,14 +4,11 @@ module Julewire
   module Core
     module Execution
       class Scope
-        EMPTY_HASH = {}.freeze
-        private_constant :EMPTY_HASH
-
         attr_reader :finished_at
 
-        def initialize(type:, id: nil, execution: EMPTY_HASH, execution_owned: false, summary_event: nil, # rubocop:disable Metrics/ParameterLists
-                       summary_severity: nil, summary_source: nil, attributes: EMPTY_HASH, carry: EMPTY_HASH,
-                       context: EMPTY_HASH, labels: EMPTY_HASH, neutral: EMPTY_HASH, parent: nil, started_at: nil)
+        def initialize(type:, id: nil, execution: nil, execution_owned: false, summary_event: nil, # rubocop:disable Metrics/ParameterLists
+                       summary_severity: nil, summary_source: nil, attributes: nil, carry: nil,
+                       context: nil, labels: nil, neutral: nil, parent: nil, started_at: nil)
           @identity = ScopeIdentity.new(
             type: type,
             id: id,
@@ -37,7 +34,7 @@ module Julewire
         def depth = @identity.depth
 
         def execution_hash
-          Fields::FieldSet.deep_dup(frozen_execution_hash)
+          Fields::FieldSet.deep_dup_owned(frozen_execution_hash)
         end
 
         def frozen_execution_hash
@@ -45,7 +42,7 @@ module Julewire
         end
 
         def inheritable_execution_hash
-          Fields::FieldSet.deep_dup(@execution)
+          Fields::FieldSet.deep_dup_owned(@execution)
         end
 
         def context_hash = @fields.context_hash
@@ -96,7 +93,7 @@ module Julewire
           end
         end
 
-        def add_field(section, fields, owned: false)
+        def add_field(section, fields, owned:)
           @fields.add(section, fields, owned: owned)
         end
 
@@ -105,23 +102,22 @@ module Julewire
           @fields.delete(:carry, path)
         end
 
-        def with_field(section, fields, owned: false, &)
-          @fields.with(section, fields, owned: owned, &)
+        def with_field(section, fields, owned: false, **keyword_fields, &)
+          @fields.with(section, fields, owned: owned, **keyword_fields, &)
         end
 
         def with_context(fields = nil, owned: false, **keyword_fields, &)
-          @fields.with(:context, fields, owned: owned, **keyword_fields, &)
+          with_field(:context, fields, owned: owned, **keyword_fields, &)
         end
 
         def with_carry(fields = nil, owned: false, **keyword_fields, &)
-          @fields.with(:carry, fields, owned: owned, **keyword_fields, &)
+          with_field(:carry, fields, owned: owned, **keyword_fields, &)
         end
 
         def without_carry(path, &)
-          normalized_path = Fields::Internal.normalize_path(path)
-          raise ArgumentError, "carry path is required" if normalized_path.empty?
+          raise ArgumentError, "carry path is required" if Fields::Internal.normalize_path(path).empty?
 
-          @fields.without(:carry, normalized_path, &)
+          @fields.without(:carry, path, &)
         end
 
         def add_summary(fields, owned: false)
@@ -149,12 +145,12 @@ module Julewire
         end
 
         def summary_record_input
-          @summary_state.record_input(**summary_record_fields(timestamp: finished_at || frozen_time(Time.now.utc)))
+          @summary_state.record_input(**summary_record_fields(timestamp: frozen_time(Time.now.utc)))
         end
 
         def owned_summary_record_input
           @summary_state.owned_record_input(
-            **summary_record_fields(timestamp: finished_at || frozen_time(Time.now.utc))
+            **summary_record_fields(timestamp: frozen_time(Time.now.utc))
           )
         end
 
@@ -186,7 +182,7 @@ module Julewire
 
         def frozen_time(value) = @identity.frozen_time(value)
 
-        def initialize_state(context:, attributes:, labels:, carry: {}, neutral: {})
+        def initialize_state(context:, attributes:, labels:, carry:, neutral:)
           @fields = ScopeFields.new(
             context: context,
             carry: carry,
@@ -194,7 +190,6 @@ module Julewire
             labels: labels,
             neutral: neutral
           )
-          @finished_at = nil
         end
 
         def summary_state(event, severity, source)

data/lib/julewire/core/execution/scope_fields.rb

@@ -4,9 +4,6 @@ module Julewire
   module Core
     module Execution
       class ScopeFields
-        EMPTY_HASH = {}.freeze
-        private_constant :EMPTY_HASH
-
         attr_reader :stacks
 
         def initialize(context:, attributes:, labels:, carry:, neutral:)
@@ -36,18 +33,14 @@ module Julewire
         end
 
         def labels_hash
-          return {} if @labels.empty?
-
           Fields::FieldSet.deep_dup(@labels)
         end
 
         def frozen_labels_hash
-          return EMPTY_HASH if @labels.empty?
-
           @frozen_labels_hash ||= Fields::Internal.frozen_copy(@labels)
         end
 
-        def add(section, fields, owned: false)
+        def add(section, fields, owned:)
           @stacks.add(section, fields, owned: owned)
         end
 
@@ -55,7 +48,7 @@ module Julewire
           @stacks.delete(section, path)
         end
 
-        def with(section, fields = nil, owned: false, **keyword_fields, &)
+        def with(section, fields, owned:, **keyword_fields, &)
           @stacks.with(section, fields, owned: owned, **keyword_fields, &)
         end
 
@@ -66,9 +59,7 @@ module Julewire
         private
 
         def normalized_static_hash(value)
-          return EMPTY_HASH if value.is_a?(Hash) && value.empty?
-
-          Fields::FieldSet.deep_symbolize_keys(value)
+          Fields::FieldSet.deep_symbolize_keys(value || {})
         end
       end
     end

data/lib/julewire/core/execution/scope_identity.rb

@@ -55,15 +55,7 @@ module Julewire
         end
 
         def freeze_identity_value(value)
-          case value
-          when String
-            copy = value.frozen? ? value : value.dup
-            copy.freeze
-          when Symbol, Numeric, true, false, nil
-            value
-          else
-            Serialization::ValueCopy.call(value, freeze_values: true)
-          end
+          Serialization::ValueCopy.call(value, freeze_values: true)
         end
       end
     end

data/lib/julewire/core/execution/scope_snapshot.rb

@@ -4,10 +4,8 @@ module Julewire
   module Core
     module Execution
       class ScopeSnapshot
-        EMPTY_HASH = {}.freeze
-        private_constant :EMPTY_HASH
-
-        def initialize(execution: {}, carry: {}, attributes: {}, labels: {}, neutral: {}, lineage: nil)
+        def initialize(execution: {}, carry: {}, attributes: {}, labels: {}, neutral: {}, lineage: nil, owned: false)
+          @owned = owned
           @execution = normalized_hash(execution)
           @carry = normalized_hash(carry)
           @attributes = normalized_hash(attributes)
@@ -17,11 +15,11 @@ module Julewire
         end
 
         def execution_hash
-          Fields::FieldSet.deep_dup(frozen_execution_hash)
+          Fields::FieldSet.deep_dup_owned(frozen_execution_hash)
         end
 
         def frozen_execution_hash
-          @frozen_execution_hash ||= Fields::Internal.frozen_copy(@execution)
+          @frozen_execution_hash ||= Fields::Internal.frozen_owned_copy(@execution)
         end
 
         attr_reader :lineage
@@ -30,61 +28,42 @@ module Julewire
 
         def type = @execution[:type]
 
-        def started_at = nil
+        def started_at; end
 
-        def finished_at = nil
+        def finished_at; end
 
-        def parent = nil
+        def parent; end
 
         def context_hash = {}
 
-        def carry_hash
-          return {} if @carry.empty?
-
-          Fields::FieldSet.deep_dup(@carry)
-        end
-
-        def attributes_hash
-          return {} if @attributes.empty?
+        def carry_hash = Fields::FieldSet.deep_dup_owned(@carry)
 
-          Fields::FieldSet.deep_dup(@attributes)
-        end
+        def attributes_hash = Fields::FieldSet.deep_dup_owned(@attributes)
 
-        def neutral_hash
-          return {} if @neutral.empty?
+        def neutral_hash = Fields::FieldSet.deep_dup_owned(@neutral)
 
-          Fields::FieldSet.deep_dup(@neutral)
-        end
-
-        def labels_hash
-          return {} if @labels.empty?
-
-          Fields::FieldSet.deep_dup(@labels)
-        end
+        def labels_hash = Fields::FieldSet.deep_dup_owned(@labels)
 
         def summary_hash = {}
 
         def metrics_hash = {}
 
-        def frozen_labels_hash
-          return EMPTY_HASH if @labels.empty?
-
-          @frozen_labels_hash ||= Fields::Internal.frozen_copy(@labels)
-        end
+        def frozen_labels_hash = (@frozen_labels_hash ||= Fields::Internal.frozen_owned_copy(@labels))
 
         def execution_reference_for_child
           reference = {}
-          reference[:type] = @execution[:type] if @execution.key?(:type)
-          reference[:id] = @execution[:id] if @execution.key?(:id)
-          reference.empty? ? nil : Fields::Internal.frozen_copy(reference)
+          reference[:type] = @execution.fetch(:type) if @execution.key?(:type)
+          reference[:id] = @execution.fetch(:id) if @execution.key?(:id)
+          Fields::Internal.frozen_copy(reference) unless reference.empty?
         end
 
         private
 
         def normalized_hash(value)
-          return EMPTY_HASH if value.is_a?(Hash) && value.empty?
+          return Fields::FieldSet.deep_symbolize_keys(value) unless @owned
 
-          Fields::FieldSet.deep_symbolize_keys(value)
+          Serialization::DeepFreeze.validate_symbol_hash(value)
+          Fields::FieldSet.deep_dup_owned(value)
         end
       end
     end

data/lib/julewire/core/execution/summary_state.rb

@@ -16,31 +16,29 @@ module Julewire
           @attributes = {}
           @metrics = {}
           @errors = []
-          @error_severity = nil
-          @record_input = nil
         end
 
         def payload_hash
-          Fields::FieldSet.deep_dup(@payload)
+          Fields::FieldSet.deep_dup_owned(@payload)
         end
 
         def metrics_hash
-          Fields::FieldSet.deep_dup(@metrics)
+          Fields::FieldSet.deep_dup_owned(@metrics)
         end
 
-        def add(fields, owned: false)
+        def add(fields, owned:)
           merge_fields!(@payload, fields, owned: owned)
         end
 
-        def add_attributes(fields, owned: false)
+        def add_attributes(fields, owned:)
           deep_merge_fields!(@attributes, fields, owned: owned)
         end
 
-        def add_neutral(fields, owned: false)
+        def add_neutral(fields, owned:)
           deep_merge_fields!(@neutral, fields, owned: owned)
         end
 
-        def increment_attribute(path, by: 1)
+        def increment_attribute(path, by:)
           path = Fields::Internal.normalize_path(path)
           raise ArgumentError, "attribute path is required" if path.empty?
 
@@ -48,7 +46,7 @@ module Julewire
           key = path.last
           value = Fields::FieldSet.value_for(container, key, default: MISSING)
           existing = !value.equal?(MISSING)
-          container[Fields::Internal.normalize_key(key)] = incremented_value(value, by, existing: existing)
+          container[key] = incremented_value(value, by, existing: existing)
         end
 
         def increment(key, by: 1)
@@ -66,7 +64,7 @@ module Julewire
           values << Fields::FieldSet.deep_dup(value)
         end
 
-        def record_error(error, severity: nil)
+        def record_error(error, severity:)
           @errors << error
           @error_severity = Records::Severity.normalize(severity) unless severity.nil?
         end
@@ -90,7 +88,7 @@ module Julewire
         end
 
         def record_input(**fields)
-          Fields::FieldSet.deep_dup(owned_record_input(**fields))
+          Fields::FieldSet.deep_dup_owned(owned_record_input(**fields))
         end
 
         def owned_record_input(**fields)
@@ -143,13 +141,13 @@ module Julewire
         def attributes_hash(base_attributes)
           return base_attributes if @attributes.empty?
 
-          Fields::Internal.deep_merge(base_attributes, @attributes)
+          Fields::Internal.deep_merge_owned!(Fields::FieldSet.deep_dup_owned(base_attributes), @attributes)
         end
 
         def neutral_hash(base_neutral)
           return base_neutral if @neutral.empty?
 
-          Fields::Internal.deep_merge(base_neutral, @neutral)
+          Fields::Internal.deep_merge_owned!(Fields::FieldSet.deep_dup_owned(base_neutral), @neutral)
         end
 
         def array_value(value, existing:)
@@ -173,23 +171,22 @@ module Julewire
         end
 
         def measurement_base(key)
-          unless key.is_a?(String) || key.is_a?(Symbol)
+          unless key.is_a?(String) || key.instance_of?(Symbol)
             raise ArgumentError, "measurement key must be a String or Symbol"
           end
 
-          base = key.to_s
+          base = key
           raise ArgumentError, "measurement key is required" if base.empty?
 
           base
         end
 
         def attribute_container(path)
-          path[0...-1].reduce(@attributes) do |container, key|
-            normalized = Fields::Internal.normalize_key(key)
-            child = container[normalized]
+          path[...-1].reduce(@attributes) do |container, key|
+            child = container[key]
             unless child.is_a?(Hash)
               child = {}
-              container[normalized] = child
+              container[key] = child
             end
             child
           end

data/lib/julewire/core/execution/view.rb

@@ -16,15 +16,6 @@ module Julewire
           @finished_at = scope.finished_at
           @parent_scope = scope.parent
           @lineage = scope.lineage
-          @parent = nil
-          @execution_hash = nil
-          @context_hash = nil
-          @carry_hash = nil
-          @neutral_hash = nil
-          @attributes_hash = nil
-          @labels_hash = nil
-          @summary_hash = nil
-          @metrics_hash = nil
         end
 
         def parent
@@ -33,21 +24,21 @@ module Julewire
           @parent ||= self.class.new(@parent_scope)
         end
 
-        def execution_hash = Fields::FieldSet.deep_dup(@execution_hash ||= @scope.frozen_execution_hash)
+        def execution_hash = Fields::FieldSet.deep_dup_owned(@execution_hash ||= @scope.frozen_execution_hash)
 
-        def context_hash = Fields::FieldSet.deep_dup(@context_hash ||= @scope.context_hash)
+        def context_hash = Fields::FieldSet.deep_dup_owned(@context_hash ||= @scope.context_hash)
 
-        def carry_hash = Fields::FieldSet.deep_dup(@carry_hash ||= @scope.carry_hash)
+        def carry_hash = Fields::FieldSet.deep_dup_owned(@carry_hash ||= @scope.carry_hash)
 
-        def neutral_hash = Fields::FieldSet.deep_dup(@neutral_hash ||= @scope.neutral_hash)
+        def neutral_hash = Fields::FieldSet.deep_dup_owned(@neutral_hash ||= @scope.neutral_hash)
 
-        def attributes_hash = Fields::FieldSet.deep_dup(@attributes_hash ||= @scope.attributes_hash)
+        def attributes_hash = Fields::FieldSet.deep_dup_owned(@attributes_hash ||= @scope.attributes_hash)
 
-        def labels_hash = Fields::FieldSet.deep_dup(@labels_hash ||= @scope.frozen_labels_hash)
+        def labels_hash = Fields::FieldSet.deep_dup_owned(@labels_hash ||= @scope.frozen_labels_hash)
 
-        def summary_hash = Fields::FieldSet.deep_dup(@summary_hash ||= @scope.summary_hash)
+        def summary_hash = Fields::FieldSet.deep_dup_owned(@summary_hash ||= @scope.summary_hash)
 
-        def metrics_hash = Fields::FieldSet.deep_dup(@metrics_hash ||= @scope.metrics_hash)
+        def metrics_hash = Fields::FieldSet.deep_dup_owned(@metrics_hash ||= @scope.metrics_hash)
 
         def finished? = !finished_at.nil?
       end

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, owned: true) { 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, owned: true) { 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