julewire-core 1.0.0 → 1.1.0

data/lib/julewire/core/integration/event_subscriber.rb

@@ -55,7 +55,7 @@ module Julewire
 
         private
 
-        def after_configuration_change = nil
+        def after_configuration_change; end
       end
     end
   end

data/lib/julewire/core/integration/facade.rb

@@ -6,24 +6,16 @@ module Julewire
       # @api integration_spi
       module Facade
         class << self
-          def emit(record = Core::UNSET, enforce_level: true, **fields)
+          def emit(record = UNSET, enforce_level: true, **fields)
             record = Core.emit_input(record, fields)
-            runtime = RuntimeLocator.current
-            if runtime.respond_to?(:emit_integration)
-              runtime.emit_integration(record, enforce_level: enforce_level)
-            elsif enforce_level
-              runtime.emit(record)
-            else
-              runtime.emit_without_level(record)
-            end
+            RuntimeLocator.current.emit_integration(record, enforce_level: enforce_level)
             nil
           end
 
-          def with_execution(type:, **, &)
-            raise ArgumentError, "block required" unless block_given?
-
+          def with_execution(type:, **options, &)
             integration_write_section!(:execution)
-            RuntimeLocator.current.with_execution(type: type, owned: true, **, &)
+            validate_owned_fields!(options)
+            RuntimeLocator.current.with_execution(type: type, owned: true, **options, &)
           end
 
           def with_attributes(fields, &)
@@ -88,6 +80,7 @@ module Julewire
             raise ArgumentError, "block required" unless block_given?
 
             integration_write_section!(section)
+            validate_owned_fields!(fields)
             case section
             when :attributes then ContextStore.current.with_attributes(fields, owned: true, &)
             when :carry then ContextStore.current.with_carry(fields, owned: true, &)
@@ -104,7 +97,6 @@ module Julewire
             when :context then ContextStore.current.add_context(fields, owned: true)
             when :neutral then ContextStore.current.add_neutral(fields, owned: true)
             end
-            nil
           end
 
           def integration_write_section!(section)
@@ -115,10 +107,15 @@ module Julewire
             raise ArgumentError, "integration cannot write #{section}"
           end
 
+          def validate_owned_fields!(value)
+            Protocol.validate_symbol_hash(value)
+          end
+
           def add_summary_fields(fields, writer)
             integration_write_section!(:summary)
+            validate_owned_fields!(fields)
             scope = ContextStore.current.current_scope
-            return unless scope && fields.is_a?(Hash)
+            return unless scope
 
             fields = Serialization::DeepCompactEmpty.compact_owned!(fields)
             scope.public_send(writer, fields, owned: true) unless fields.empty?

data/lib/julewire/core/integration/fork_hooks.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "concurrent/map"
+
 module Julewire
   module Core
     module Integration
@@ -7,51 +9,28 @@ module Julewire
         Entry = Data.define(:integration, :component, :callback)
         private_constant :Entry
 
-        @mutex = Mutex.new
-        @entries = {}
+        @entries = Concurrent::Map.new
 
         class << self
           def register(integration, component:, &callback)
             raise ArgumentError, "block required" unless callback
 
-            name = integration_name(integration)
-            component = component.to_sym
-            register_entry(name, component, callback)
+            validate_symbol_name!(integration, name: :integration)
+            validate_symbol_name!(component, name: :component)
+            register_entry(integration, component, callback)
           end
 
           def run
-            snapshot = mutex.synchronize { entries.values }
+            snapshot = entries.values
             snapshot.each { run_entry(it) }
-            nil
-          end
-
-          def after_fork!
-            @mutex = Mutex.new
-            nil
-          end
-
-          def reset!
-            mutex.synchronize { entries.clear }
-            nil
           end
 
           private
 
-          attr_reader :entries, :mutex
+          attr_reader :entries
 
           def register_entry(name, component, callback)
-            mutex.synchronize do
-              entries[[name, component]] = Entry.new(name, component, callback)
-            end
-            nil
-          rescue StandardError => e
-            Diagnostics::ProcessIntegrationHealth.record_failure(
-              name,
-              e,
-              action: :register_after_fork,
-              component: component
-            )
-            nil
+            entries[[name, component]] = Entry.new(name, component, callback)
           end
 
           def run_entry(entry)
@@ -63,14 +42,11 @@ module Julewire
               action: :after_fork,
               component: entry.component
             )
-            nil
           end
 
-          def integration_name(value)
-            name = value.to_s
-            raise ArgumentError, "integration name is required" if name.empty?
-
-            name.to_sym
+          def validate_symbol_name!(value, name:)
+            raise TypeError, "#{name} must be a Symbol" unless value.instance_of?(Symbol)
+            raise ArgumentError, "#{name} is required" if value == :""
           end
         end
       end

data/lib/julewire/core/integration/health.rb

@@ -12,7 +12,6 @@ module Julewire
             else
               Diagnostics::ProcessIntegrationHealth.record_failure(integration, error, **metadata)
             end
-            nil
           end
 
           def record_success(integration, runtime: nil, **)
@@ -21,14 +20,12 @@ module Julewire
             else
               Diagnostics::ProcessIntegrationHealth.record_success(integration)
             end
-            nil
           end
 
           def with_failure_health(integration, component:, action:, runtime: nil, **metadata)
             yield.tap { record_success(integration, runtime: runtime) }
           rescue StandardError => e
             record_failure(integration, e, runtime: runtime, component: component, action: action, **metadata)
-            nil
           end
 
           def scoped(integration, runtime: nil)

data/lib/julewire/core/integration/ivar_state.rb

@@ -10,18 +10,13 @@ module Julewire
         end
 
         def fetch(owner)
-          return unless owner.respond_to?(:instance_variable_get)
-
           owner.instance_variable_get(@marker)
         rescue StandardError
           nil
         end
 
         def store(owner, value)
-          return value unless owner.respond_to?(:instance_variable_set)
-
           owner.instance_variable_set(@marker, value)
-          value
         rescue StandardError
           value
         end

data/lib/julewire/core/integration/protocol.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Core
+    module Integration
+      # @api integration_spi
+      module Protocol
+        class << self
+          def validate_symbol_keys(value)
+            Serialization::DeepFreeze.validate_symbol_keys(value)
+          end
+
+          def validate_symbol_hash(value)
+            Serialization::DeepFreeze.validate_symbol_hash(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/julewire/core/integration/settings.rb

@@ -13,7 +13,7 @@ module Julewire
 
         module ClassMethods
           def setting(name, default: nil, predicate: false, validate: nil, &block)
-            settings_defaults[name] = block || proc { default }
+            settings_defaults[name] = block || -> { default }
             settings_validators[name] = validate if validate
             ivar = :"@#{name}"
 
@@ -60,7 +60,7 @@ module Julewire
         end
 
         def setting_default(default)
-          Core::Fields::FieldSet.deep_dup(instance_exec(&default))
+          Fields::FieldSet.deep_dup(instance_exec(&default))
         end
 
         def validate_settings!
@@ -81,9 +81,9 @@ module Julewire
           case validator
           when Symbol
             validator_method = method(validator)
-            validator_method.arity == 1 ? validator_method.call(value) : validator_method.call(value, name)
+            validator_method.arity == 2 ? validator_method.call(value, name) : validator_method.call(value)
           else
-            validator.arity == 1 ? instance_exec(value, &validator) : instance_exec(value, name, &validator)
+            validator.arity == 2 ? instance_exec(value, name, &validator) : instance_exec(value, &validator)
           end
         end
       end

data/lib/julewire/core/integration/subscriber_install.rb

@@ -17,10 +17,10 @@ module Julewire
         private
 
         def update_subscription(configuration)
-          @subscription&.update(configuration)
+          @subscription.update(configuration)
         end
 
-        def store_subscription(subscriber, unsubscribe: nil)
+        def store_subscription(subscriber, unsubscribe:)
           @subscription = Subscription.new(subscriber, unsubscribe: unsubscribe)
           subscriber
         end

data/lib/julewire/core/integration/subscription.rb

@@ -7,7 +7,8 @@ module Julewire
       class Subscription
         attr_reader :subscriber
 
-        def initialize(subscriber, unsubscribe: nil)
+        def initialize(subscriber, unsubscribe:)
+          Validation.validate_callable!(unsubscribe, name: :unsubscribe)
           @subscriber = subscriber
           @unsubscribe = unsubscribe
         end
@@ -18,7 +19,7 @@ module Julewire
         end
 
         def reset
-          @unsubscribe&.call
+          @unsubscribe.call
           nil
         rescue StandardError
           nil

data/lib/julewire/core/integration/values.rb

@@ -59,8 +59,6 @@ module Julewire
             def path_value(object, path, default: nil)
               current = object
               Array(path).each do |key|
-                return default if current.nil?
-
                 current = indexed_value(current, key)
                 return default if current.equal?(MISSING)
               end
@@ -68,11 +66,6 @@ module Julewire
             end
 
             def first_value(source, keys:)
-              if source.is_a?(Hash)
-                found = direct_hash_first_value(source, keys)
-                return found unless found.equal?(MISSING)
-              end
-
               keys.each do |key|
                 found = indexed_value(source, key)
                 return found unless found.equal?(MISSING) || blank_value?(found)
@@ -82,16 +75,6 @@ module Julewire
 
             private
 
-            def direct_hash_first_value(source, keys)
-              keys.each do |key|
-                next unless source.key?(key)
-
-                found = source[key]
-                return found unless blank_value?(found)
-              end
-              MISSING
-            end
-
             def indexed_value(source, key)
               return hash_value(source, key, default: MISSING) if source.is_a?(Hash)
               return MISSING unless source.respond_to?(:[])

data/lib/julewire/core/local_storage.rb

@@ -15,15 +15,12 @@ module Julewire
       private_constant :RUNTIME_KEY, :CONTEXT_STORE_THREAD_KEY, :CONTEXT_STORE_FIBER_IVAR
 
       @runtime_ref = Concurrent::AtomicReference.new
-      @runtime_mutex = Mutex.new
 
       class << self
         def runtime
           return ractor_runtime if ractor_local_storage?
 
-          runtime_ref.get || runtime_mutex.synchronize do
-            runtime_ref.get || Runtime.new.tap { runtime_ref.set(it) }
-          end
+          runtime_ref.update { it || Runtime.new }
         end
 
         def runtime=(runtime)
@@ -42,22 +39,9 @@ module Julewire
           store_context(nil)
         end
 
-        def after_fork!
-          runtime = runtime_ref.get
-          @runtime_mutex = Mutex.new
-          @runtime_ref = Concurrent::AtomicReference.new(runtime)
-          nil
-        end
-
-        # Private testing seam for storage-selection behavior.
-        def main_ractor?
-          ::Ractor.main?
-        end
-        private :main_ractor?
-
         private
 
-        attr_reader :runtime_mutex, :runtime_ref
+        attr_reader :runtime_ref
 
         def ractor_runtime
           ::Ractor.store_if_absent(RUNTIME_KEY) { Runtime.new }
@@ -83,7 +67,7 @@ module Julewire
         end
 
         def ractor_local_storage?
-          !main_ractor?
+          !::Ractor.main?
         end
       end
     end

data/lib/julewire/core/processing/invalid_result_failure.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Core
+    module Processing
+      module InvalidResultFailure
+        class << self
+          def build(message:, phase:, processor_name:, record_metadata:, result:)
+            [
+              ArgumentError.new(message),
+              {
+                phase: phase,
+                processor: processor_name,
+                record_metadata: record_metadata,
+                result_class: result.class.name
+              }
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/julewire/core/processing/level_threshold.rb

@@ -4,7 +4,6 @@ module Julewire
   module Core
     module Processing
       class LevelThreshold
-        DEFAULT_EVENT = "log"
         DEFAULT_SEVERITY = :info
 
         attr_reader :level
@@ -20,32 +19,26 @@ module Julewire
         end
 
         def raw_input_allowed?(input)
-          return allow?(DEFAULT_SEVERITY) unless Records::RawInput.hash_input?(input)
-
-          severity, invalid, invalid_raw_value = raw_input_severity(input)
+          severity, invalid_raw_value = raw_input_severity(input)
           allowed = allow?(severity)
           # Surviving inputs warn later at Records::Draft normalization.
-          record_invalid_raw_severity(input, invalid_raw_value) if invalid && !allowed
+          record_invalid_raw_severity(invalid_raw_value) unless invalid_raw_value.equal?(MISSING) || allowed
           allowed
         end
 
         private
 
         def raw_input_severity(input)
-          return [DEFAULT_SEVERITY, false, nil] unless Records::RawInput.explicit_severity?(input)
+          return [DEFAULT_SEVERITY, MISSING] unless Records::RawInput.explicit_severity?(input)
 
           raw_value = Records::RawInput.value(input, :severity)
-          [Records::Severity.normalize(raw_value), false, nil]
+          [Records::Severity.normalize(raw_value), MISSING]
         rescue ArgumentError
-          [DEFAULT_SEVERITY, true, raw_value]
+          [DEFAULT_SEVERITY, raw_value]
         end
 
-        def record_invalid_raw_severity(input, raw_value)
-          @invalid_severity_reporter.call(
-            raw_value,
-            source: Records::RawInput.value(input, :source),
-            event: Records::RawInput.value(input, :event) || DEFAULT_EVENT
-          )
+        def record_invalid_raw_severity(raw_value)
+          @invalid_severity_reporter.call(raw_value)
         end
       end
     end

data/lib/julewire/core/processing/match.rb

@@ -17,7 +17,7 @@ module Julewire
           raise ArgumentError, "match handler is required" unless handler
 
           conditions = normalize_conditions(conditions, keyword_conditions)
-          @rules << Rule.new(conditions.freeze, handler)
+          @rules << Rule.new(conditions, handler)
           self
         end
 
@@ -46,7 +46,9 @@ module Julewire
         end
 
         def matches_conditions?(draft, conditions)
-          conditions.all? { |key, pattern| matches_value?(pattern, draft[key]) }
+          conditions.all? do |key, pattern|
+            draft.key?(key) && matches_value?(pattern, draft.fetch(key))
+          end
         end
 
         def matches_value?(pattern, value)
@@ -64,8 +66,8 @@ module Julewire
           return false unless value.is_a?(Hash)
 
           pattern.all? do |key, nested_pattern|
-            nested_value = Fields::FieldSet.value_for(value, key, default: Core::UNSET)
-            !nested_value.equal?(Core::UNSET) && matches_value?(nested_pattern, nested_value)
+            nested_value = Fields::FieldSet.value_for(value, key, default: UNSET)
+            !nested_value.equal?(UNSET) && matches_value?(nested_pattern, nested_value)
           end
         end
       end