julewire-core 1.0.0 → 1.1.0

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

@@ -15,16 +15,15 @@ module Julewire
             clean_hash(execution, RELATIONSHIP_KEYS)
           end
 
-          def clean_owned_execution_hash(execution)
-            clean_hash!(execution, RELATIONSHIP_KEYS)
+          def clean_normalized_lazy_relationship_hash(execution)
+            clean_normalized_hash(execution, LAZY_RELATIONSHIP_KEYS)
           end
 
-          def clean_lazy_relationship_hash(execution)
-            clean_hash(execution, LAZY_RELATIONSHIP_KEYS)
+          def clean_owned_execution_hash(execution)
+            clean_hash!(execution, RELATIONSHIP_KEYS)
           end
 
           def from_execution_hash(execution)
-            execution = {} unless execution.is_a?(Hash)
             new(
               reference: execution_reference(execution),
               root_reference: relationship_value(execution, :root),
@@ -50,6 +49,11 @@ module Julewire
             clean_hash!(copy, keys)
           end
 
+          def clean_normalized_hash(execution, keys)
+            copy = execution.is_a?(Hash) ? execution.dup : {}
+            clean_hash!(copy, keys)
+          end
+
           def clean_hash!(copy, keys)
             keys.each do |key|
               Fields::Internal.delete_key!(copy, key)
@@ -63,7 +67,9 @@ module Julewire
             id = reference_value(execution, :id)
             reference[:type] = type unless type.equal?(MISSING)
             reference[:id] = id unless id.equal?(MISSING)
-            reference.empty? ? nil : reference
+            return if reference.empty?
+
+            reference
           end
         end
 
@@ -76,15 +82,18 @@ module Julewire
           ancestors: nil,
           ancestors_truncated: false
         )
-          @parent_lineage = parent_lineage
           @depth = depth_value(depth, parent_lineage)
-          @root_reference = freeze_reference(root_reference || root_reference_for(reference, parent_lineage))
+          @root_reference = freeze_reference(
+            root_reference || parent_lineage&.root_reference_for_child || reference
+          )
           @parent_reference = freeze_reference(parent_reference)
           @ancestor_references = freeze_ancestors(ancestors)
           @ancestors_truncated = ancestors_truncated ? true : false
-          @ancestor_references_for_child = nil
-          @truncated = nil
-          @truncated_computed = false
+          return if @ancestor_references
+
+          references = inherited_ancestor_references(parent_lineage)
+          @ancestor_references = references.last(MAX_ANCESTORS).freeze
+          @ancestors_truncated ||= references.length > MAX_ANCESTORS
         end
 
         def merge_into_frozen(execution)
@@ -95,34 +104,14 @@ module Julewire
           hash.freeze
         end
 
-        def ancestors
-          references = @ancestor_references_for_child
-          return references if references
-
-          materialize_ancestor_references_for_child
-        end
-
-        def truncated?
-          return @truncated if @truncated_computed
+        def ancestors = @ancestor_references
 
-          @truncated = @ancestors_truncated || ancestor_count_exceeds_limit?
-          @truncated_computed = true
-          @truncated
-        end
-
-        def freeze
-          return self if frozen?
-
-          ancestors
-          truncated?
-          @parent_lineage = nil
-          super
-        end
+        def truncated? = @ancestors_truncated
 
         protected
 
         def ancestor_references_for_child
-          ancestors
+          @ancestor_references
         end
 
         def root_reference_for_child
@@ -131,37 +120,14 @@ module Julewire
 
         private
 
-        attr_reader :parent_lineage
-
-        def materialize_ancestor_references_for_child
-          if @ancestor_references
-            @ancestor_references_for_child = @ancestor_references.freeze
-          else
-            references = build_ancestor_references
-            @truncated = references.length > MAX_ANCESTORS
-            @truncated_computed = true
-            @ancestor_references_for_child = references.last(MAX_ANCESTORS).freeze
-          end
-        end
-
-        def ancestor_count_exceeds_limit?
-          return false if @ancestor_references_for_child
-
-          build_ancestor_references.length > MAX_ANCESTORS
-        end
-
         def depth_value(depth, parent_lineage)
-          return depth if depth.is_a?(Integer) && depth.positive?
+          return depth if depth.instance_of?(Integer) && depth.positive?
           return parent_lineage.depth + 1 if parent_lineage
 
           1
         end
 
-        def root_reference_for(reference, parent_lineage)
-          parent_lineage ? parent_lineage.root_reference_for_child : reference
-        end
-
-        def build_ancestor_references
+        def inherited_ancestor_references(parent_lineage)
           return [] unless parent_lineage && @parent_reference
 
           parent_lineage.ancestor_references_for_child + [@parent_reference]
@@ -175,15 +141,13 @@ module Julewire
 
         def freeze_reference(reference)
           return unless reference
-          return reference if reference.frozen?
 
           Serialization::ValueCopy.call(reference, freeze_values: true)
         end
 
         def frozen_hash_copy(value)
           value.each_with_object({}) do |(key, field_value), copy|
-            copy[Fields::Internal.normalize_key(key)] =
-              Serialization::ValueCopy.call(field_value, freeze_values: true)
+            copy[key] = Serialization::ValueCopy.call(field_value, freeze_values: true)
           end
         end
       end

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

@@ -1,27 +1,23 @@
 # frozen_string_literal: true
 
+require "concurrent/atomic/atomic_boolean"
+
 module Julewire
   module Core
     module Execution
       class MeasurementHandle
         def initialize(&finish)
           @finish = finish
-          @finished = false
-          @mutex = Mutex.new
+          @finished = Concurrent::AtomicBoolean.new
         end
 
         def finish
-          @mutex.synchronize do
-            return if @finished
+          return unless @finished.make_true
 
-            @finished = true
-            @finish.call
-          end
+          @finish.call
         end
 
-        def finished?
-          @mutex.synchronize { @finished }
-        end
+        def finished? = @finished.true?
       end
     end
   end

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, &)
-          with_field(:context, fields, &)
+        def with_context(fields = nil, owned: false, **keyword_fields, &)
+          with_field(:context, fields, owned: owned, **keyword_fields, &)
         end
 
-        def with_carry(fields, &)
-          with_field(:carry, fields, &)
+        def with_carry(fields = nil, owned: false, **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,8 +48,8 @@ module Julewire
           @stacks.delete(section, path)
         end
 
-        def with(section, fields, owned: false, &)
-          @stacks.with(section, fields, owned: owned, &)
+        def with(section, fields, owned:, **keyword_fields, &)
+          @stacks.with(section, fields, owned: owned, **keyword_fields, &)
         end
 
         def without(section, path, &)
@@ -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