julewire-core 1.0.0 → 1.1.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: julewire-core
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Alexander Grebennik
@@ -87,6 +87,7 @@ files:
 - lib/julewire/core/destinations/collection.rb
 - lib/julewire/core/destinations/definition.rb
 - lib/julewire/core/destinations/destination.rb
+- lib/julewire/core/destinations/processor_handling.rb
 - lib/julewire/core/destinations/registry.rb
 - lib/julewire/core/destinations/sink.rb
 - lib/julewire/core/destinations/synchronized_output.rb
@@ -139,6 +140,7 @@ files:
 - lib/julewire/core/integration/health.rb
 - lib/julewire/core/integration/ivar_state.rb
 - lib/julewire/core/integration/lifecycle.rb
+- lib/julewire/core/integration/protocol.rb
 - lib/julewire/core/integration/scoped.rb
 - lib/julewire/core/integration/settings.rb
 - lib/julewire/core/integration/subscriber_install.rb
@@ -147,6 +149,7 @@ files:
 - lib/julewire/core/lifecycle_error.rb
 - lib/julewire/core/local_storage.rb
 - lib/julewire/core/processing.rb
+- lib/julewire/core/processing/invalid_result_failure.rb
 - lib/julewire/core/processing/level_threshold.rb
 - lib/julewire/core/processing/match.rb
 - lib/julewire/core/processing/pipeline.rb
@@ -157,6 +160,7 @@ files:
 - lib/julewire/core/processing/sampling.rb
 - lib/julewire/core/propagation.rb
 - lib/julewire/core/propagation/carrier.rb
+- lib/julewire/core/records/build_input.rb
 - lib/julewire/core/records/console_formatter.rb
 - lib/julewire/core/records/deconstruct.rb
 - lib/julewire/core/records/display_message.rb
@@ -173,7 +177,6 @@ files:
 - lib/julewire/core/runtime_registry.rb
 - lib/julewire/core/runtime_state.rb
 - lib/julewire/core/scheduling/deadline.rb
-- lib/julewire/core/scheduling/deadline_scheduler.rb
 - lib/julewire/core/scheduling/shared_scheduler.rb
 - lib/julewire/core/sentinel.rb
 - lib/julewire/core/serialization/backtrace_limiter.rb
@@ -187,25 +190,10 @@ files:
 - lib/julewire/core/serialization/serializer.rb
 - lib/julewire/core/serialization/serializer_pool.rb
 - lib/julewire/core/serialization/text_encoder.rb
+- lib/julewire/core/serialization/truncation_metadata.rb
 - lib/julewire/core/serialization/value_copy.rb
 - lib/julewire/core/serialization/value_traversal.rb
 - lib/julewire/core/testing.rb
-- lib/julewire/core/testing/chaos.rb
-- lib/julewire/core/testing/chaos/catalog.rb
-- lib/julewire/core/testing/chaos/core_runtime.rb
-- lib/julewire/core/testing/chaos/destination.rb
-- lib/julewire/core/testing/chaos/emitter.rb
-- lib/julewire/core/testing/chaos/raising_output.rb
-- lib/julewire/core/testing/contracts.rb
-- lib/julewire/core/testing/contracts/component.rb
-- lib/julewire/core/testing/contracts/deadline_scheduler.rb
-- lib/julewire/core/testing/contracts/integration.rb
-- lib/julewire/core/testing/contracts/integration_fields.rb
-- lib/julewire/core/testing/contracts/record_draft.rb
-- lib/julewire/core/testing/contracts/runtime.rb
-- lib/julewire/core/testing/contracts/wire.rb
-- lib/julewire/core/testing/coverage.rb
-- lib/julewire/core/testing/test_reports.rb
 - lib/julewire/core/validation.rb
 - lib/julewire/core/version.rb
 - lib/julewire/error.rb
@@ -231,7 +219,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.14
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Execution-scoped structured logging core for Ruby applications.
 test_files: []

data/lib/julewire/core/scheduling/deadline_scheduler.rb

@@ -1,207 +0,0 @@
-# frozen_string_literal: true
-
-module Julewire
-  module Core
-    module Scheduling
-      # @api integration_spi
-      class DeadlineScheduler
-        CLOCK = Process::CLOCK_MONOTONIC
-        Entry = Data.define(:deadline, :token, :callback)
-
-        def initialize(thread_name:, idle: :keep_alive)
-          @thread_name = thread_name
-          @idle = idle
-          @mutex = Mutex.new
-          @condition = ConditionVariable.new
-          @entries = {}
-          # A heap keeps timeout scheduling cheap without non-shareable scheduler dependencies.
-          @heap = []
-          @next_token = 0
-          @generation = 0
-          @pid = Process.pid
-          @thread = nil
-        end
-
-        def schedule(timeout, &block)
-          raise ArgumentError, "block required" unless block
-
-          timeout = Float(timeout)
-          if timeout <= 0
-            yield
-            return
-          end
-
-          @mutex.synchronize do
-            token = next_token
-            entry = Entry.new(monotonic_time + timeout, token, block)
-            @entries[token] = entry
-            heap_push(entry)
-            ensure_thread
-            @condition.signal
-            token
-          end
-        end
-
-        def cancel(token)
-          return unless token
-
-          @mutex.synchronize do
-            @entries.delete(token)
-            @condition.signal
-          end
-        end
-
-        def after_fork!
-          if @pid == Process.pid
-            reset_same_process
-          else
-            reset_after_fork
-          end
-
-          self
-        end
-
-        private
-
-        def reset_same_process
-          @mutex.synchronize do
-            @generation += 1
-            @entries = {}
-            @heap = []
-            @next_token = 0
-            @thread = nil
-            @condition.broadcast
-          end
-        end
-
-        def reset_after_fork
-          @mutex = Mutex.new
-          @condition = ConditionVariable.new
-          @entries = {}
-          @heap = []
-          @next_token = 0
-          @generation += 1
-          @pid = Process.pid
-          @thread = nil
-        end
-
-        def next_token
-          @next_token += 1
-        end
-
-        def ensure_thread
-          return if @thread&.alive?
-
-          generation = @generation
-          @thread = Thread.new { run(generation) }
-          @thread.name = @thread_name
-          @thread.report_on_exception = false
-        end
-
-        def run(generation)
-          loop do
-            callback = next_expired_callback(generation)
-            return unless callback
-
-            safe_call(callback)
-          end
-        end
-
-        def next_expired_callback(generation)
-          @mutex.synchronize do
-            loop do
-              return unless generation == @generation
-
-              discard_cancelled_head
-              if @heap.empty?
-                return clear_thread if exit_when_idle?
-
-                @condition.wait(@mutex)
-                next
-              end
-
-              entry = @heap.fetch(0)
-              remaining = entry.deadline - monotonic_time
-              if remaining.positive?
-                @condition.wait(@mutex, remaining)
-              else
-                heap_pop
-                @entries.delete(entry.token)
-                return entry.callback
-              end
-            end
-          end
-        end
-
-        def discard_cancelled_head
-          heap_pop while @heap.any? && !@entries.key?(@heap.fetch(0).token)
-        end
-
-        def clear_thread
-          @thread = nil
-          nil
-        end
-
-        def exit_when_idle?
-          @idle == :exit
-        end
-
-        def safe_call(callback)
-          callback.call
-        rescue StandardError
-          nil
-        end
-
-        def monotonic_time
-          Process.clock_gettime(CLOCK)
-        end
-
-        def heap_push(entry)
-          @heap << entry
-          sift_up(@heap.length - 1)
-        end
-
-        def heap_pop
-          return @heap.pop if @heap.one?
-
-          top = @heap.fetch(0)
-          @heap[0] = @heap.pop
-          sift_down(0)
-          top
-        end
-
-        def sift_up(index)
-          while index.positive?
-            parent = (index - 1) / 2
-            break if earlier_or_equal?(@heap.fetch(parent), @heap.fetch(index))
-
-            swap_heap(index, parent)
-            index = parent
-          end
-        end
-
-        def sift_down(index)
-          loop do
-            left = (index * 2) + 1
-            right = left + 1
-            smallest = index
-            smallest = left if left < @heap.length && earlier_or_equal?(@heap.fetch(left), @heap.fetch(smallest))
-            smallest = right if right < @heap.length && earlier_or_equal?(@heap.fetch(right), @heap.fetch(smallest))
-            break if smallest == index
-
-            swap_heap(index, smallest)
-            index = smallest
-          end
-        end
-
-        def earlier_or_equal?(left, right)
-          left.deadline < right.deadline || (left.deadline == right.deadline && left.token <= right.token)
-        end
-
-        def swap_heap(left, right)
-          @heap[left], @heap[right] = @heap[right], @heap[left]
-        end
-      end
-    end
-  end
-end

data/lib/julewire/core/testing/chaos/catalog.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module Julewire
-  module Core
-    module Testing
-      module Chaos
-        class Catalog
-          Entry = Data.define(:kind, :name, :exercise)
-          KINDS = %i[processor formatter encoder destination subscriber listener].freeze
-
-          attr_reader :entries
-
-          class << self
-            def build
-              catalog = new
-              yield catalog if block_given?
-              catalog
-            end
-
-            def assert_contract(test_context, catalog:, errors:)
-              entries = catalog.entries
-              raise ArgumentError, "chaos catalog must have entries" if entries.empty?
-
-              entries.each do |entry|
-                assert_entry(test_context, entry, errors)
-              end
-              nil
-            end
-
-            private
-
-            def assert_entry(test_context, entry, errors)
-              Chaos.assert_contained(
-                test_context,
-                errors: errors,
-                description: "#{entry.kind} #{entry.name}"
-              ) do |error|
-                entry.exercise.call(error)
-              end
-            end
-          end
-
-          def initialize
-            @entries = []
-          end
-
-          def processor(name, &) = register(:processor, name, &)
-
-          def formatter(name, &) = register(:formatter, name, &)
-
-          def encoder(name, &) = register(:encoder, name, &)
-
-          def destination(name, &) = register(:destination, name, &)
-
-          def subscriber(name, &) = register(:subscriber, name, &)
-
-          def listener(name, &) = register(:listener, name, &)
-
-          private
-
-          def register(kind, name, &exercise)
-            raise ArgumentError, "unknown chaos component kind #{kind.inspect}" unless KINDS.include?(kind)
-            raise ArgumentError, "chaos component exercise block required" unless exercise
-
-            @entries << Entry.new(kind, Core.normalize_name(name), exercise)
-            self
-          end
-        end
-      end
-    end
-  end
-end

data/lib/julewire/core/testing/chaos/core_runtime.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-module Julewire
-  module Core
-    module Testing
-      module Chaos
-        module CoreRuntime
-          SCENARIOS = %i[
-            destination_processor
-            drop_callback
-            encoder
-            failure_callback
-            formatter
-            lifecycle_after_fork
-            lifecycle_flush
-            output
-            pipeline_processor
-          ].freeze
-
-          private_constant :SCENARIOS
-
-          class << self
-            def assert_contract(test_context, runtime:, reset:, errors:)
-              SCENARIOS.each do |scenario|
-                errors.each do |error|
-                  assert_scenario(test_context, runtime, reset, scenario, error)
-                end
-              end
-              nil
-            end
-
-            private
-
-            def assert_scenario(test_context, runtime, reset, scenario, error)
-              reset.call
-              send(:"exercise_#{scenario}", runtime, error)
-            rescue StandardError => e
-              test_context.flunk(
-                "expected core #{scenario} failure to be contained, " \
-                "#{error.class} leaked #{e.class}: #{e.message}"
-              )
-            ensure
-              reset.call
-            end
-
-            def exercise_destination_processor(runtime, error)
-              configure_destination(runtime, processors: [Chaos.raiser(error)])
-              runtime.emit("chaos")
-            end
-
-            def exercise_drop_callback(runtime, error)
-              trigger = RuntimeError.new("julewire chaos formatter trigger")
-              configure_destination(runtime, formatter: Chaos.raiser(trigger), on_drop: Chaos.raiser(error))
-              runtime.emit("chaos")
-            end
-
-            def exercise_encoder(runtime, error)
-              configure_destination(runtime, encoder: Chaos.raiser(error))
-              runtime.emit("chaos")
-            end
-
-            def exercise_failure_callback(runtime, error)
-              trigger = RuntimeError.new("julewire chaos output trigger")
-              configure_destination(
-                runtime,
-                output: RaisingOutput.new(trigger, failures: %i[write]),
-                runtime_on_failure: Chaos.raiser(error)
-              )
-              runtime.emit("chaos")
-            end
-
-            def exercise_formatter(runtime, error)
-              configure_destination(runtime, formatter: Chaos.raiser(error))
-              runtime.emit("chaos")
-            end
-
-            def exercise_lifecycle_after_fork(runtime, error)
-              configure_destination(runtime, output: RaisingOutput.new(error, failures: %i[after_fork]))
-              runtime.after_fork!
-            end
-
-            def exercise_lifecycle_flush(runtime, error)
-              configure_destination(runtime, output: RaisingOutput.new(error, failures: %i[flush]))
-              runtime.flush
-            end
-
-            def exercise_output(runtime, error)
-              configure_destination(runtime, output: RaisingOutput.new(error, failures: %i[write]))
-              runtime.emit("chaos")
-            end
-
-            def exercise_pipeline_processor(runtime, error)
-              runtime.configure do |config|
-                config.destinations.use(:default, output: NullOutput.new)
-                config.processors.use(Chaos.raiser(error))
-              end
-              runtime.emit("chaos")
-            end
-
-            def configure_destination(runtime, output: NullOutput.new, formatter: nil, encoder: nil,
-                                      on_drop: nil, processors: nil, runtime_on_failure: nil)
-              runtime.configure do |config|
-                config.on_failure = runtime_on_failure if runtime_on_failure
-                config.destinations.clear
-                config.destinations.use(
-                  :default,
-                  encoder: encoder || Julewire::Core::Serialization::JsonEncoder.new,
-                  formatter: formatter || Julewire::Core::Records::Formatter.new,
-                  on_drop: on_drop,
-                  output: output,
-                  processors: processors || []
-                )
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/julewire/core/testing/chaos/destination.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Julewire
-  module Core
-    module Testing
-      module Chaos
-        module Destination
-          class << self
-            def assert_contract(test_context, record:, formatter:, encoder:, output:, callbacks:, errors:)
-              {
-                formatter: formatter,
-                encoder: encoder,
-                output: output,
-                callbacks: callbacks
-              }.compact.each do |scenario, builder|
-                assert_scenario(test_context, scenario, builder, record, errors)
-              end
-              nil
-            end
-
-            private
-
-            def assert_scenario(test_context, scenario, builder, record, errors)
-              errors.each do |error|
-                assert_error_contained(test_context, scenario, builder, record, error)
-              end
-              nil
-            end
-
-            def assert_error_contained(test_context, scenario, builder, record, error)
-              Chaos.assert_contained(
-                test_context,
-                errors: [error],
-                description: "destination #{scenario}"
-              ) do |build_error|
-                destination = builder.call(build_error)
-                destination.emit(record)
-              ensure
-                close_destination(destination)
-              end
-            end
-
-            def close_destination(destination)
-              return unless destination.respond_to?(:close)
-
-              destination.close(timeout: 0)
-            rescue StandardError
-              nil
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/julewire/core/testing/chaos/emitter.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Julewire
-  module Core
-    module Testing
-      module Chaos
-        module Emitter
-          class << self
-            def assert_contract(test_context, component:, build:, exercise:, errors:)
-              Chaos.assert_contained(test_context, errors: errors, description: component) do |error|
-                emitter = build.call(error)
-                exercise.call(emitter, error)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/julewire/core/testing/chaos/raising_output.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Julewire
-  module Core
-    module Testing
-      module Chaos
-        class RaisingOutput
-          def initialize(error, failures:)
-            @error = error
-            @failures = failures
-          end
-
-          def write(value)
-            raise @error if @failures.include?(:write)
-
-            value.bytesize
-          end
-
-          def flush
-            raise @error if @failures.include?(:flush)
-
-            self
-          end
-
-          def close
-            raise @error if @failures.include?(:close)
-
-            self
-          end
-
-          def after_fork!
-            raise @error if @failures.include?(:after_fork)
-
-            self
-          end
-        end
-
-        private_constant :RaisingOutput
-      end
-    end
-  end
-end

data/lib/julewire/core/testing/chaos.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Julewire
-  module Core
-    module Testing
-      # @api extension
-      module Chaos
-        DEFAULT_ERRORS = [
-          RuntimeError.new("julewire chaos runtime"),
-          ArgumentError.new("julewire chaos argument"),
-          TypeError.new("julewire chaos type")
-        ].freeze
-        class << self
-          def assert_contained(test_context, errors: DEFAULT_ERRORS, description: nil)
-            raise ArgumentError, "block required" unless block_given?
-
-            errors.each do |error|
-              yield error
-            rescue StandardError => e
-              test_context.flunk(containment_message(description, error, e))
-            end
-            nil
-          end
-
-          def assert_core_runtime_containment(test_context, runtime: Julewire, reset: nil, errors: DEFAULT_ERRORS)
-            reset ||= -> { runtime.reset! }
-            raise ArgumentError, "reset must respond to call" unless reset.respond_to?(:call)
-
-            CoreRuntime.assert_contract(test_context, runtime: runtime, reset: reset, errors: errors)
-          end
-
-          def catalog(&)
-            Catalog.build(&)
-          end
-
-          def assert_discovered_chaos_contracts(test_context, catalog:, errors: DEFAULT_ERRORS)
-            Catalog.assert_contract(test_context, catalog: catalog, errors: errors)
-          end
-
-          def assert_destination_chaos_contract(test_context, record:, formatter:, encoder:, output:,
-                                                callbacks: nil, errors: DEFAULT_ERRORS)
-            Destination.assert_contract(
-              test_context,
-              record: record,
-              formatter: formatter,
-              encoder: encoder,
-              output: output,
-              callbacks: callbacks,
-              errors: errors
-            )
-          end
-
-          def assert_emitter_chaos_contract(test_context, component:, build:, exercise:, errors: DEFAULT_ERRORS)
-            Emitter.assert_contract(
-              test_context,
-              component: component,
-              build: build,
-              exercise: exercise,
-              errors: errors
-            )
-          end
-
-          def raiser(error = RuntimeError.new("julewire chaos"))
-            ->(*) { raise error }
-          end
-
-          private
-
-          def containment_message(description, expected_error, leaked_error)
-            unless description
-              return "expected #{expected_error.class} to be contained, leaked #{leaked_error.class}: #{leaked_error}"
-            end
-
-            "expected #{description} chaos to be contained, leaked #{leaked_error.class}: #{leaked_error}"
-          end
-        end
-      end
-    end
-  end
-end