julewire-core 1.0.0

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Core
+    module Integration
+      # @api integration_spi
+      class Subscription
+        attr_reader :subscriber
+
+        def initialize(subscriber, unsubscribe: nil)
+          @subscriber = subscriber
+          @unsubscribe = unsubscribe
+        end
+
+        def update(configuration)
+          @subscriber.configuration = configuration
+          @subscriber
+        end
+
+        def reset
+          @unsubscribe&.call
+          nil
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Julewire
+  module Core
+    module Integration
+      # @api integration_spi
+      module Values
+        EMPTY_HASH = {}.freeze
+
+        module Common
+          def empty_hash = EMPTY_HASH
+
+          def blank_value?(value)
+            value.nil? || (value.respond_to?(:empty?) && value.empty?)
+          rescue StandardError
+            false
+          end
+        end
+
+        private_constant :EMPTY_HASH, :Common
+
+        # @api integration_spi
+        module Read
+          extend Common
+
+          class << self
+            def blank?(value)
+              blank_value?(value)
+            end
+
+            def hash_value(hash, key, default: nil)
+              return default unless hash.is_a?(Hash)
+
+              direct_hash_value(hash, key, default)
+            end
+
+            def value(object, key, default: nil)
+              return hash_value(object, key, default: default) if object.is_a?(Hash)
+
+              return default unless object.respond_to?(key)
+
+              object.public_send(key)
+            rescue StandardError
+              default
+            end
+
+            def nested_value(object, *keys, default: nil)
+              current = object
+              keys.each do |key|
+                return default if current.nil?
+
+                current = value(current, key)
+              end
+              current.nil? ? default : current
+            end
+
+            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
+              current
+            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)
+              end
+              nil
+            end
+
+            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?(:[])
+
+              source[key]
+            rescue StandardError
+              MISSING
+            end
+
+            def direct_hash_value(hash, key, default)
+              return hash[key] if hash.key?(key)
+
+              case key
+              when Symbol then symbol_key_value(hash, key, default)
+              when String then string_key_value(hash, key, default)
+              else default
+              end
+            end
+
+            def symbol_key_value(hash, key, default)
+              string_key = key.name
+              return hash[string_key] if hash.key?(string_key)
+
+              default
+            end
+
+            def string_key_value(hash, key, default)
+              symbol_key = key.to_sym
+              return hash[symbol_key] if hash.key?(symbol_key)
+
+              default
+            end
+          end
+        end
+
+        # @api integration_spi
+        module Shape
+          extend Common
+
+          class << self
+            def timestamp(value)
+              return unless value
+              return value.utc.iso8601(9) if value.respond_to?(:utc) && value.respond_to?(:iso8601)
+              return value unless value.respond_to?(:divmod)
+
+              seconds, nanoseconds = value.divmod(1_000_000_000)
+              Time.at(seconds, nanoseconds, :nanosecond).utc.iso8601(9)
+            rescue StandardError
+              nil
+            end
+
+            def payload_hash(value)
+              case value
+              when nil
+                empty_hash
+              when Hash
+                return empty_hash if value.empty?
+
+                Fields::FieldSet.deep_symbolize_keys(value)
+              else
+                { Fields::FieldSet::VALUE_KEY => value }
+              end
+            end
+
+            def hash_or_empty(value)
+              return empty_hash unless value.is_a?(Hash)
+              return empty_hash if value.empty?
+
+              Fields::FieldSet.deep_symbolize_keys(value)
+            end
+
+            def append_field(fields, key, value, compact_empty: false)
+              return if value.nil?
+              return if compact_empty && (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
+
+              fields[key] = value
+              nil
+            end
+
+            def append_compact_field(fields, key, value)
+              append_field(fields, key, value, compact_empty: true)
+            end
+
+            def source_location_attributes(location)
+              return {} unless location.is_a?(Hash)
+
+              Fields::AttributeKeys.fields(
+                Fields::AttributeKeys::CODE_FILE_PATH => Read.first_value(location, keys: %i[filepath path file]),
+                Fields::AttributeKeys::CODE_LINE_NUMBER => Read.first_value(location, keys: %i[lineno line]),
+                Fields::AttributeKeys::CODE_FUNCTION_NAME => Read.first_value(location, keys: %i[label function])
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/julewire/core/lifecycle_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Core
+    class LifecycleError < Error; end
+  end
+end

data/lib/julewire/core/local_storage.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "concurrent/atomic/atomic_reference"
+
+module Julewire
+  module Core
+    # @api internal
+    # Process/ractor-local storage for facade lookups. The ractor bridge can set
+    # the current runtime from inside a child ractor, but the getter side still
+    # runs inside core through Julewire.* facade calls.
+    module LocalStorage
+      RUNTIME_KEY = :__julewire_core_runtime__
+      CONTEXT_STORE_THREAD_KEY = :__julewire_core_context_store__
+      CONTEXT_STORE_FIBER_IVAR = :@__julewire_core_context_store__
+      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
+        end
+
+        def runtime=(runtime)
+          if ractor_local_storage?
+            ::Ractor[RUNTIME_KEY] = runtime
+          else
+            runtime_ref.set(runtime)
+          end
+        end
+
+        def context_store
+          context_store_value || store_context(ContextStore.new)
+        end
+
+        def reset_context_store!
+          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
+
+        def ractor_runtime
+          ::Ractor.store_if_absent(RUNTIME_KEY) { Runtime.new }
+        end
+
+        def context_store_value
+          if ractor_local_storage?
+            # Child-ractor bridge work is thread-scoped; main-ractor app work is fiber-scoped.
+            Thread.current[CONTEXT_STORE_THREAD_KEY]
+          else
+            # Do not use Fiber#storage here: child fibers inherit it by default,
+            # while Julewire context only propagates through Julewire.fiber.
+            Fiber.current.instance_variable_get(CONTEXT_STORE_FIBER_IVAR)
+          end
+        end
+
+        def store_context(value)
+          if ractor_local_storage?
+            Thread.current[CONTEXT_STORE_THREAD_KEY] = value
+          else
+            Fiber.current.instance_variable_set(CONTEXT_STORE_FIBER_IVAR, value)
+          end
+        end
+
+        def ractor_local_storage?
+          !main_ractor?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Core
+    module Processing
+      class LevelThreshold
+        DEFAULT_EVENT = "log"
+        DEFAULT_SEVERITY = :info
+
+        attr_reader :level
+
+        def initialize(level:, invalid_severity_reporter: Diagnostics::InvalidSeverityReporter)
+          @level = Records::Severity.normalize(level)
+          @level_rank = Records::Severity.rank(@level)
+          @invalid_severity_reporter = invalid_severity_reporter
+        end
+
+        def allow?(severity)
+          Records::Severity.rank(severity) >= @level_rank
+        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)
+          allowed = allow?(severity)
+          # Surviving inputs warn later at Records::Draft normalization.
+          record_invalid_raw_severity(input, invalid_raw_value) if invalid && !allowed
+          allowed
+        end
+
+        private
+
+        def raw_input_severity(input)
+          return [DEFAULT_SEVERITY, false, nil] unless Records::RawInput.explicit_severity?(input)
+
+          raw_value = Records::RawInput.value(input, :severity)
+          [Records::Severity.normalize(raw_value), false, nil]
+        rescue ArgumentError
+          [DEFAULT_SEVERITY, true, 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
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Core
+    module Processing
+      # @api extension
+      class Match
+        Rule = Data.define(:conditions, :handler)
+        private_constant :Rule
+
+        def initialize(&)
+          @rules = []
+          instance_eval(&) if block_given?
+        end
+
+        def on(conditions = nil, **keyword_conditions, &handler)
+          raise ArgumentError, "match handler is required" unless handler
+
+          conditions = normalize_conditions(conditions, keyword_conditions)
+          @rules << Rule.new(conditions.freeze, handler)
+          self
+        end
+
+        def call(draft)
+          @rules.each do |rule|
+            next unless matches_conditions?(draft, rule.conditions)
+
+            result = rule.handler.call(draft)
+            return result if result == :drop || result.is_a?(Records::Draft)
+          end
+          nil
+        end
+
+        private
+
+        def normalize_conditions(conditions, keyword_conditions)
+          fields = case conditions
+                   when nil then {}
+                   when Hash then conditions.dup
+                   else raise ArgumentError, "match conditions must be a Hash"
+                   end
+          fields.merge!(keyword_conditions)
+          raise ArgumentError, "match conditions are required" if fields.empty?
+
+          fields
+        end
+
+        def matches_conditions?(draft, conditions)
+          conditions.all? { |key, pattern| matches_value?(pattern, draft[key]) }
+        end
+
+        def matches_value?(pattern, value)
+          case pattern
+          when Hash then matches_hash?(pattern, value)
+          when Proc then pattern.call(value)
+          when Regexp then value.is_a?(String) && pattern.match?(value)
+          when Range then pattern.cover?(value)
+          when Module then value.is_a?(pattern)
+          else pattern == value
+          end
+        end
+
+        def matches_hash?(pattern, value)
+          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)
+          end
+        end
+      end
+    end
+  end
+end