julewire-core 1.0.0 → 1.1.0

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

@@ -5,11 +5,10 @@ module Julewire
     module Diagnostics
       module InternalRecords
         class << self
-          def emit_error(error, error_backtrace_lines:)
-            Core::Records::Draft.build(
+          def emit_error(error)
+            Records::Draft.build(
               {
                 severity: :error,
-                kind: :point,
                 event: "julewire.emit_error",
                 source: "julewire",
                 message: "Julewire emit failed",
@@ -17,17 +16,15 @@ module Julewire
                   error: failure_details(error)
                 }
               },
-              context: {},
-              scope: nil,
-              error_backtrace_lines: error_backtrace_lines
+              context: nil,
+              scope: nil
             )
           end
 
-          def processor_error(processor_name:, error:, record_metadata:, error_backtrace_lines:)
-            Core::Records::Draft.build(
+          def processor_error(processor_name:, error:, record_metadata:)
+            Records::Draft.build(
               {
                 severity: :error,
-                kind: :point,
                 event: "julewire.processor_error",
                 source: "julewire",
                 message: "Julewire processor failed",
@@ -38,9 +35,8 @@ module Julewire
                   record: record_metadata
                 }
               },
-              context: {},
-              scope: nil,
-              error_backtrace_lines: error_backtrace_lines
+              context: nil,
+              scope: nil
             )
           end
 

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,42 +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