julewire-core 1.0.1 → 1.1.1

data/lib/julewire/core/diagnostics/invalid_severity_reporter.rb

@@ -1,64 +1,41 @@
 # frozen_string_literal: true
 
+require "concurrent/atomic/atomic_boolean"
+require "concurrent/atomic/atomic_fixnum"
+
 module Julewire
   module Core
     module Diagnostics
       module InvalidSeverityReporter
-        @warned = false
-        @mutex = Mutex.new
+        @warned = Concurrent::AtomicBoolean.new
 
         class RuntimeCounter
           def initialize
-            @mutex = Mutex.new
-            @count = 0
-            @last = nil
+            @count = Concurrent::AtomicFixnum.new
           end
 
-          def call(value, source: nil, event: nil)
-            metadata = InvalidSeverityReporter.metadata(value, source: source, event: event)
-            @mutex.synchronize do
-              @count += 1
-              @last = metadata
-            end
+          def call(value)
+            metadata = InvalidSeverityReporter.metadata(value)
+            @count.increment
             InvalidSeverityReporter.warn_once(metadata)
           rescue StandardError
             nil
           end
 
           def health
-            @mutex.synchronize do
-              {
-                count: @count,
-                last_event: @last&.fetch(:event, nil),
-                last_source: @last&.fetch(:source, nil),
-                last_value_class: @last&.fetch(:value_class, nil)
-              }.compact
-            end
+            { count: @count.value }
           end
 
           def reset!
-            @mutex.synchronize do
-              @count = 0
-              @last = nil
-            end
-            nil
-          end
-
-          def reset_after_fork!
-            @mutex = Mutex.new
-            @count = 0
-            @last = nil
-            nil
+            @count.value = 0
           end
         end
 
         private_constant :RuntimeCounter
 
         class << self
-          def call(value, source: nil, event: nil)
-            warning_only.call(value, source: source, event: event)
-          rescue StandardError
-            nil
+          def call(value)
+            warning_only.call(value)
           end
 
           def counter = RuntimeCounter.new
@@ -71,22 +48,11 @@ module Julewire
           end
 
           def reset!
-            @mutex.synchronize { @warned = false }
-            nil
-          end
-
-          def reset_after_fork!
-            @mutex = Mutex.new
-            @warned = false
-            nil
+            @warned.make_false
           end
 
-          def metadata(value, source:, event:)
-            {
-              event: event,
-              source: source,
-              value_class: value.class.name || value.class.to_s
-            }.compact.freeze
+          def metadata(value)
+            { value_class: value.class.to_s }.freeze
           rescue StandardError
             { value_class: "unknown" }.freeze
           end
@@ -98,12 +64,7 @@ module Julewire
           end
 
           def first_warning?
-            @mutex.synchronize do
-              return false if @warned
-
-              @warned = true
-              true
-            end
+            @warned.make_true
           end
         end
       end

data/lib/julewire/core/diagnostics/meta_observer.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "concurrent/atomic/atomic_boolean"
+require "concurrent/atomic/atomic_reference"
+
 module Julewire
   module Core
     module Diagnostics
@@ -39,31 +42,26 @@ module Julewire
           @interval = Validation.validate_integer_limit!(interval, name: :interval, positive: true)
           @include_ok = include_ok ? true : false
           @scheduler = scheduler
-          @mutex = Mutex.new
-          @last_signature = nil
-          @last_failure = nil
-          @started = false
-          @stopped = false
-          @token = nil
+          @last_failure = Concurrent::AtomicReference.new
+          @last_signature = Concurrent::AtomicReference.new
+          @running = Concurrent::AtomicBoolean.new
+          @schedule_mutex = Mutex.new
           @serializer_pool_key = :"julewire_core_meta_observer_serializers_#{object_id}"
         end
 
         def start!
-          @mutex.synchronize do
-            return self if @started && !@stopped
+          return self unless @running.make_true
 
-            @started = true
-            @stopped = false
-            schedule_next
-          end
+          schedule_next
           self
         end
 
         def stop!
-          token = @mutex.synchronize do
-            @stopped = true
-            @started = false
-            @token
+          token = @schedule_mutex.synchronize do
+            @running.make_false
+            token = @token
+            @token = nil
+            token
           end
           @scheduler.cancel(token) if token
           self
@@ -72,12 +70,7 @@ module Julewire
         def sample!
           health = @runtime.health
           signature = signature_for(health)
-          changed = @mutex.synchronize do
-            changed = signature != @last_signature
-            @last_signature = signature
-            changed
-          end
-          return false unless changed
+          return false if signature.eql?(@last_signature.get_and_set(signature))
           return false unless emit_health?(health)
 
           emit_health(health)
@@ -88,35 +81,38 @@ module Julewire
         end
 
         def health
-          @mutex.synchronize do
-            {
-              event: @event,
-              include_ok: @include_ok,
-              interval: @interval,
-              last_failure: @last_failure,
-              observed_runtime: @runtime_name,
-              running: @started && !@stopped,
-              status: @last_failure ? :degraded : :ok,
-              target_runtime: @target_name
-            }.compact.freeze
-          end
+          failure = @last_failure.get
+          {
+            event: @event,
+            include_ok: @include_ok,
+            interval: @interval,
+            last_failure: failure,
+            observed_runtime: @runtime_name,
+            running: @running.true?,
+            status: failure ? :degraded : :ok,
+            target_runtime: @target_name
+          }.compact.freeze
         end
 
         private
 
         def schedule_next
-          @token = @scheduler.schedule(@interval) { scheduled_sample }
+          @schedule_mutex.synchronize do
+            @token = @scheduler.schedule(@interval) { scheduled_sample } if @running.true?
+          end
         end
 
         def scheduled_sample
+          return false unless @running.true?
+
           sample!
-          @mutex.synchronize { schedule_next unless @stopped }
+          schedule_next
         rescue StandardError => e
           record_failure(e)
         end
 
         def emit_health?(health)
-          @include_ok || health[:status] != :ok
+          @include_ok || !health[:status].eql?(:ok)
         end
 
         def emit_health(health)
@@ -137,23 +133,20 @@ module Julewire
         end
 
         def signature_for(health)
-          serializer = cached_serializer
-          return build_serializer.serialize(health).hash if serializer.in_use?
-
-          serializer.serialize(health).hash
+          Serialization::SerializerPool.serialize_with(cached_serializer, health) { build_serializer }
         end
 
         def cached_serializer
-          Serialization::SerializerPool.serializer(@serializer_pool_key, :signature) { build_serializer }
+          Serialization::SerializerPool.serializer(@serializer_pool_key, nil) { build_serializer }
         end
 
         def build_serializer
-          Serialization::Serializer.new(compact_empty: true)
+          Serializer.new(compact_empty: true)
         end
 
         def record_failure(error)
           failure = FailureSnapshot.build(error, phase: :meta_observer)
-          @mutex.synchronize { @last_failure = failure }
+          @last_failure.set(failure)
         end
       end
     end

data/lib/julewire/core/diagnostics/process_integration_health.rb

@@ -14,11 +14,6 @@ module Julewire
           def health = @store.health
 
           def reset! = @store.reset!
-
-          def after_fork!
-            @store = IntegrationHealthStore.new
-            nil
-          end
         end
       end
     end

data/lib/julewire/core/diagnostics/tail/renderer.rb

@@ -27,7 +27,7 @@ module Julewire
 
           def payload_for(entry)
             record = entry.record
-            record.merge("timestamp" => record["timestamp"] || entry.at.iso8601(6))
+            record.merge("timestamp" => record["timestamp"] || entry.at)
           end
         end
       end

data/lib/julewire/core/diagnostics/tail.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "concurrent/atomic/atomic_reference"
+
 module Julewire
   module Core
     module Diagnostics
@@ -8,6 +10,9 @@ module Julewire
         DEFAULT_NAME = :tail
         COUNTER_KEYS = %i[captured failures].freeze
         Entry = Data.define(:sequence, :at, :record)
+        State = Data.define(:sequence, :items)
+        EMPTY_ENTRIES = [].freeze
+        private_constant :State, :EMPTY_ENTRIES
 
         class << self
           def attach!(runtime = Julewire, **)
@@ -39,11 +44,10 @@ module Julewire
 
         def emit(record)
           snapshot = snapshot_record(record)
-          @mutex.synchronize do
-            @sequence += 1
-            entry = Entry.new(@sequence, Time.now.utc, snapshot)
-            @entries << entry
-            @entries.shift while @entries.length > @capacity
+          @state_ref.update do |state|
+            sequence = state.sequence + 1
+            entries = (state.items + [Entry.new(sequence, Time.now.utc, snapshot)]).last(@capacity)
+            State.new(sequence, entries)
           end
           @health.increment(:captured)
           nil
@@ -54,7 +58,7 @@ module Julewire
 
         def entries(limit: nil)
           limit = normalize_limit(limit)
-          snapshot = @mutex.synchronize { @entries.dup }
+          snapshot = @state_ref.get.items.dup
           limit ? snapshot.last(limit) : snapshot
         end
 
@@ -72,10 +76,8 @@ module Julewire
         end
 
         def clear
-          @mutex.synchronize do
-            @entries.clear
-          end
-          @health.clear_degraded!
+          @state_ref.update { State.new(it.sequence, EMPTY_ENTRIES) }
+          @health.clear_failures!
           self
         end
 
@@ -89,17 +91,14 @@ module Julewire
         end
 
         def health
-          size = @mutex.synchronize { @entries.length }
-          @health.snapshot(capacity: @capacity, size: size)
+          @health.snapshot(capacity: @capacity, size: entries.length)
         end
 
         private
 
         def initialize_state
-          @mutex = Mutex.new
-          @entries = []
+          @state_ref = Concurrent::AtomicReference.new(State.new(0, EMPTY_ENTRIES))
           @health = Integration::DestinationHealth.new(counter_keys: COUNTER_KEYS)
-          @sequence = 0
           @serializer_mutex = Mutex.new
         end
 
@@ -123,7 +122,7 @@ module Julewire
           message = Records::DisplayMessage.call(record)
           return payload if blank?(message)
 
-          payload = payload.dup if payload.frozen?
+          payload = payload.dup
           payload["message"] = message
           payload
         end
@@ -131,10 +130,7 @@ module Julewire
         def serialize_payload(payload)
           return serialize_custom_payload(payload) if @serializer
 
-          serializer = cached_serializer
-          return build_serializer.serialize(payload) if serializer.in_use?
-
-          serializer.serialize(payload)
+          Serialization::SerializerPool.serialize_with(cached_serializer, payload) { build_serializer }
         end
 
         def serialize_custom_payload(payload)
@@ -142,11 +138,11 @@ module Julewire
         end
 
         def cached_serializer
-          Serialization::SerializerPool.serializer(@serializer_pool_key, :default) { build_serializer }
+          Serialization::SerializerPool.serializer(@serializer_pool_key, nil) { build_serializer }
         end
 
         def build_serializer
-          Serialization::Serializer.new(compact_empty: true)
+          Serializer.new(compact_empty: true)
         end
 
         def blank?(value)

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

@@ -74,15 +74,11 @@ module Julewire
 
           EXECUTION_OPTION_DEFAULTS.merge(options).tap do |normalized|
             normalized[:execution] = execution_fields(normalized.delete(:fields))
-            normalized[:attributes] ||= EMPTY_HASH
-            normalized[:neutral] ||= EMPTY_HASH
-            normalized[:labels] ||= EMPTY_HASH
           end
         end
 
         def execution_fields(fields)
-          return {} if fields.nil?
-          raise ArgumentError, "execution fields must be a Hash" unless fields.is_a?(Hash)
+          raise ArgumentError, "execution fields must be a Hash" unless fields.nil? || fields.is_a?(Hash)
 
           fields
         end
@@ -91,9 +87,7 @@ module Julewire
           return unless emit_summary_enabled
 
           @summary_finalizer ||= lambda do |scope|
-            next if suppress_summary_for_non_standard_exception?(scope)
-
-            @emit_summary_record.call(scope)
+            @emit_summary_record.call(scope) unless suppress_summary_for_non_standard_exception?(scope)
           end
         end
 

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "concurrent/atomic/atomic_boolean"
+
 module Julewire
   module Core
     module Execution
@@ -8,12 +10,9 @@ module Julewire
           @scope = scope
           @on_finish = on_finish
           @on_finish_failure = on_finish_failure
-          @mutex = Mutex.new
-          @finished = false
+          @finished = Concurrent::AtomicBoolean.new
         end
 
-        attr_reader :scope
-
         def snapshot = View.new(@scope)
 
         def run
@@ -32,44 +31,40 @@ module Julewire
           ContextStore.current.with_scope(@scope, &)
         end
 
-        def finish(reason: :closed, fields: {}, attributes: {}, error: nil, severity: nil)
+        def finish(reason: :closed, fields: nil, attributes: nil, error: nil, severity: nil)
           # Finishing is one-shot: retrying after partial summary mutation can
           # duplicate completion data, so failures are reported and stop here.
           return false unless mark_finished
 
           add_completion_attributes(reason)
-          @scope.add_summary(fields) unless fields.empty?
-          @scope.add_summary_attributes(attributes) unless attributes.empty?
+          @scope.add_summary(fields)
+          @scope.add_summary_attributes(attributes)
           @scope.finish_owned(error: error, severity: severity)
           call_finish
           true
         rescue StandardError => e
-          report_finish_failure(e)
+          report_finish_failure(e, phase: :summary_finish)
           false
         end
 
         private
 
         def mark_finished
-          @mutex.synchronize do
-            return false if @finished
-
-            @finished = true
-          end
+          @finished.make_true
         end
 
         def add_completion_attributes(reason)
-          @scope.add_summary_attributes({ "julewire.completion": reason.to_s }, owned: true)
+          @scope.add_summary_attributes({ "julewire.completion": reason.to_s })
         end
 
         def call_finish
           @on_finish&.call(@scope)
         rescue StandardError => e
-          report_finish_failure(e)
+          report_finish_failure(e, phase: :summary_emit)
         end
 
-        def report_finish_failure(error)
-          @on_finish_failure&.call(error)
+        def report_finish_failure(error, phase:)
+          @on_finish_failure.call(error, phase: phase)
         rescue StandardError
           nil
         end

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

@@ -24,7 +24,6 @@ module Julewire
           end
 
           def from_execution_hash(execution)
-            execution = {} unless execution.is_a?(Hash)
             new(
               reference: execution_reference(execution),
               root_reference: relationship_value(execution, :root),
@@ -68,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
 
@@ -81,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)
@@ -100,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
@@ -136,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]
@@ -180,7 +141,6 @@ module Julewire
 
         def freeze_reference(reference)
           return unless reference
-          return reference if reference.frozen?
 
           Serialization::ValueCopy.call(reference, freeze_values: true)
         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