julewire-karafka 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2348fa4e2f74ae14416481646fb82ca838306ba5f637b3ee21d38d8e25d7f1c3
-  data.tar.gz: 937a2babb22b4ed2bcc277c12d008568646a0dcef77dac25cbfb9c829b516c57
+  metadata.gz: c859473affe912e211098b9247586fb17695c366d9d554d95f4690013fe2d4dc
+  data.tar.gz: cce0973311bb175fa5c3b998706f7af2a370ff18719019962241b62242fd3903
 SHA512:
-  metadata.gz: c1ea911dce21f4ae508f70f8a8d47a9beebe35c44d235ca3d0e5a27753996634ca15f123b4c431f04c4f3fadfe1c2d1d63adfe79bdb56cf11c3a03cb45dfb516
-  data.tar.gz: db66dcbf0c4faaccd8b10a1240bdb045f307ddbc842bf375d5e2718119edef8cf5411164e58afe9c3a3e9330c0cacc8c8541d6e90ef027ad1abd8feaa1a6b314
+  metadata.gz: '09a000b1edf0d1052cb36ca3a6bbbb0cf7db1597111e9b9386ebcd61884fee68d3da8594f753b84f91eaf770dbe6aea89eafa29cec718059a6090b3f426875fc'
+  data.tar.gz: 658376067030f6873f06ea26816598163b899b78c53389b97e44547f4b03b63a74d4ea37ba0208a73c500abd55825791c7e49f1dc8dbb35d9eb3f628b8b223e8

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## Unreleased
 
+## 1.1.0 - 2026-07-20
+
+- Report unsupported WaterDrop message shapes through Karafka integration
+  health instead of silently skipping propagation.
+- Restore propagated context through owned carrier envelopes.
+- Require julewire-core 1.1.0.
+
 ## 1.0.1 - 2026-06-25
 
 - Default propagation carrier byte limits to 64 KiB and record health when

data/README.md

@@ -18,6 +18,9 @@ class KarafkaApp < Karafka::App
 end
 ```
 
+Consumer installation is explicit: pass `monitor:` or `app:` so Julewire binds to
+the intended Karafka monitor.
+
 Message processing:
 
 ```ruby

data/docs/configuration.md

@@ -2,6 +2,15 @@
 
 ## Default Path
 
+Install consumer hooks with an explicit monitor or app:
+
+```ruby
+Julewire::Karafka.install!(monitor: Karafka.monitor)
+```
+
+`install!` does not discover a global Karafka app. Passing the monitor keeps the
+integration bound to the app instance being configured.
+
 | Option | Default | Purpose |
 | --- | --- | --- |
 | `enabled` | `true` | Install the integration. |

data/julewire-karafka.gemspec

@@ -34,7 +34,7 @@ Gem::Specification.new do |spec|
   spec.executables = []
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "julewire-core", ">= 1.0.1"
+  spec.add_dependency "julewire-core", ">= 1.1.0"
   spec.add_dependency "karafka", ">= 2.5"
   spec.add_dependency "waterdrop", ">= 2.10"
   spec.add_dependency "zeitwerk", ">= 2.8.1"

data/lib/julewire/karafka/event_payload.rb

@@ -17,10 +17,11 @@ module Julewire
           payload = event_payload(event)
           return {} unless payload.is_a?(Hash)
 
-          payload.each_with_object(consumer_payload(name, payload)) do |(key, value), result|
+          fields = payload.each_with_object(consumer_payload(name, payload)) do |(key, value), result|
             safe = safe_value(key, value)
             result[key] = safe unless safe.nil?
           end
+          Core::Fields::FieldSet.deep_symbolize_keys(fields)
         rescue StandardError => e
           { payload_error: { exception_class: e.class.name } }
         end

data/lib/julewire/karafka/event_severity.rb

@@ -37,7 +37,7 @@ module Julewire
 
         def payload_severity(payload)
           value = payload_value(payload, :severity) || payload_value(payload, :level)
-          Julewire::Core::Records::Severity.normalize(value) if value
+          Core::Records::Severity.normalize(value)
         rescue StandardError
           nil
         end
@@ -85,22 +85,14 @@ module Julewire
         end
 
         def raw_event_value(event, key)
-          raw = EventPayload.event_payload(event)
-          return raw[key] if raw.respond_to?(:key?) && raw.key?(key)
-          return raw[key.to_s] if raw.respond_to?(:key?) && raw.key?(key.to_s)
-          return event[key] if event.respond_to?(:[])
-
-          nil
-        rescue StandardError
-          nil
+          Core::Integration::Values::Read.value(EventPayload.event_payload(event), key)
         end
 
         def collection_count(value)
-          return value[:count] if value.is_a?(Hash) && value.key?(:count)
-          return value["count"] if value.is_a?(Hash) && value.key?("count")
-          return value.size if value.respond_to?(:size)
+          count = Core::Integration::Values::Read.hash_value(value, :count, default: Core::UNSET)
+          return count unless count.equal?(Core::UNSET)
 
-          nil
+          value.size if value.respond_to?(:size)
         end
       end
     end

data/lib/julewire/karafka/fork_hooks.rb

@@ -11,18 +11,17 @@ module Julewire
       private_constant :EVENTS, :INSTALL_STATE
 
       class << self
-        def subscribe!(monitor, configuration: Configuration.new)
+        def subscribe!(monitor, configuration:)
           return unless configuration.enabled?
           return unless monitor.respond_to?(:subscribe)
 
-          state = INSTALL_STATE.fetch_or_store(monitor) { { events: [].freeze }.freeze }
-          subscribed_events = Array(state[:events]).dup
+          state = INSTALL_STATE.fetch_or_store(monitor) { { events: [] } }
+          subscribed_events = state.fetch(:events)
           EVENTS.each do |event_name|
             next if subscribed_events.include?(event_name)
 
             subscribed_events << event_name if subscribe_event(monitor, event_name)
           end
-          INSTALL_STATE.store(monitor, { events: subscribed_events.freeze }.freeze)
           monitor
         end
 
@@ -35,10 +34,7 @@ module Julewire
         private
 
         def subscribe_event(monitor, event_name)
-          IntegrationHealth.with_failure_health(action: :subscribe, component: :fork_hooks, event: event_name) do
-            monitor.subscribe(event_name) { handle(event_name, it) }
-            true
-          end || false
+          MonitorSubscription.subscribe(monitor, event_name, component: :fork_hooks) { handle(event_name, it) }
         end
       end
     end

data/lib/julewire/karafka/installer.rb

@@ -4,9 +4,7 @@ module Julewire
   module Karafka
     module Installer
       class << self
-        def install!(app: nil, monitor: nil, configuration: Configuration.new)
-          return false unless configuration.enabled?
-
+        def install!(app:, configuration:, monitor: nil)
           monitor ||= monitor_for(app)
           raise Error, "Karafka monitor is not available" unless monitor
 
@@ -20,10 +18,7 @@ module Julewire
         private
 
         def monitor_for(app)
-          app ||= defined?(::Karafka::App) ? ::Karafka::App : nil
-          app.config.monitor if app.respond_to?(:config)
-        rescue StandardError
-          nil
+          Core::Integration::Values::Read.nested_value(app, :config, :monitor)
         end
       end
     end

data/lib/julewire/karafka/message_context.rb

@@ -5,21 +5,24 @@ module Julewire
     module MessageContext
       class << self
         def call(message, configuration:, fields: nil, &)
-          raise ArgumentError, "block required" unless block_given?
-
           fields ||= PayloadReader.message_payload(message)
+          call_fields(fields, configuration: configuration, &)
+        end
+
+        def call_fields(fields, configuration:, &)
           carrier = carrier_for(fields, configuration)
 
-          result = Julewire::Core::Propagation::Carrier.extract_result(
+          result = Core::Propagation::Carrier.extract_result(
             carrier,
             key: configuration.carrier_key,
             max_bytes: configuration.carrier_max_bytes
           )
           record_carrier_restore_failure(result)
+          fields = Core::Fields::FieldSet.deep_symbolize_keys(fields)
 
-          Julewire::Core::Propagation.restore(result.envelope, owned: true) do
-            Julewire::Core::Integration::Facade.with_neutral(message_neutral(fields)) do
-              Julewire::Core::Integration::Facade.with_attributes(message_attributes(fields), &)
+          Core::Propagation.restore(result.envelope, owned: true) do
+            Core::Integration::Facade.with_neutral(message_neutral(fields)) do
+              Core::Integration::Facade.with_attributes(message_attributes(fields), &)
             end
           end
         end
@@ -39,17 +42,20 @@ module Julewire
         end
 
         def carrier_for(fields, configuration)
-          return {} unless configuration.propagation?
+          return unless configuration.propagation?
 
-          headers = fields[:headers].is_a?(Hash) ? fields[:headers] : {}
+          headers = fields[:headers]
+          headers = {} unless headers.is_a?(Hash)
           filter = configuration.carrier_filter
           return headers unless filter
 
-          filtered = filter.call(headers, message: fields)
-          filtered.is_a?(Hash) ? filtered : {}
-        rescue StandardError => e
-          IntegrationHealth.record_failure(e, action: :carrier_filter, component: :message_context)
-          {}
+          begin
+            filtered = filter.call(headers, message: fields)
+            filtered.is_a?(Hash) ? filtered : {}
+          rescue StandardError => e
+            IntegrationHealth.record_failure(e, action: :carrier_filter, component: :message_context)
+            {}
+          end
         end
 
         def message_attributes(fields) = { karafka: fields }

data/lib/julewire/karafka/message_execution.rb

@@ -7,9 +7,7 @@ module Julewire
       DEFAULT_SUMMARY_EVENT = "message.completed"
 
       class << self
-        def call(message, configuration: Configuration.new, **options, &)
-          raise ArgumentError, "block required" unless block_given?
-
+        def call(message, configuration:, **options, &)
           fields = PayloadReader.message_payload(message)
           execution_fields = execution_fields(options)
           type = execution_fields.delete(:type) || DEFAULT_TYPE
@@ -18,8 +16,8 @@ module Julewire
           summary_event = execution_fields.delete(:summary_event) || DEFAULT_SUMMARY_EVENT
           summary_severity = execution_fields.delete(:summary_severity)
           summary_source = execution_fields.delete(:summary_source) || configuration.source
-          MessageContext.call(message, configuration: configuration, fields: fields) do
-            Julewire::Core::Integration::Facade.with_execution(
+          MessageContext.call_fields(fields, configuration: configuration) do
+            Core::Integration::Facade.with_execution(
               type: type,
               id: id,
               emit_summary: emit_summary,
@@ -36,8 +34,7 @@ module Julewire
 
         def execution_fields(options)
           values = Core::Integration::Values::Shape
-          fields = values.hash_or_empty(options)
-          fields.empty? ? {} : fields
+          values.hash_or_empty(options).dup
         end
 
         def execution_id(fields)

data/lib/julewire/karafka/monitor_listener.rb

@@ -43,7 +43,7 @@ module Julewire
         end
       end
 
-      def initialize(configuration = Configuration.new, profile:)
+      def initialize(configuration, profile:)
         @configuration = configuration
         @profile = profile
       end
@@ -64,13 +64,12 @@ module Julewire
             source: @configuration.source,
             error: EventPayload.error(event),
             neutral: messaging_attributes(name, payload),
-            attributes: event_attributes(name, payload)
+            attributes: event_attributes(payload)
           )
         end
-        nil
       end
 
-      def event_attributes(_name, payload)
+      def event_attributes(payload)
         Core.deep_compact_empty(@profile.event_prefix.to_sym => payload)
       end
 

data/lib/julewire/karafka/monitor_subscription.rb

@@ -10,7 +10,16 @@ module Julewire
       private_constant :PROFILE_CONSTANTS
 
       class << self
-        def install!(monitor, profile:, configuration: Configuration.new)
+        def subscribe(monitor, event_name, component:, &)
+          return false unless monitor.respond_to?(:subscribe)
+
+          IntegrationHealth.with_failure_health(action: :subscribe, component:, event: event_name) do
+            monitor.subscribe(event_name, &)
+            true
+          end
+        end
+
+        def install!(monitor, profile:, configuration:)
           profile = monitor_listener_profile(profile)
           state = subscription_state(monitor, profile)
           listener = listener_for(state, configuration, profile)
@@ -23,21 +32,22 @@ module Julewire
             next if subscriptions.key?(event_name)
 
             callback = ->(event) { listener.emit(event_name, event) }
-            subscriptions[event_name] = callback if subscribe_event(monitor, event_name, profile, &callback)
+            if subscribe(monitor, event_name, component: profile.component, &callback)
+              subscriptions[event_name] = callback
+            end
           end
           store_subscription_state(monitor, listener: listener, subscriptions: subscriptions, profile: profile)
-          listener
         end
 
         private
 
         def monitor_listener_profile(profile)
-          constant_name = PROFILE_CONSTANTS.fetch(profile) { return profile }
-          MonitorListener.const_get(constant_name, false)
+          constant_name = PROFILE_CONSTANTS.fetch(profile)
+          MonitorListener.const_get(constant_name)
         end
 
         def listener_for(state, configuration, profile)
-          listener = state && state[:listener]
+          listener = state&.fetch(:listener)
           if listener
             listener.configuration = configuration
             listener
@@ -49,7 +59,7 @@ module Julewire
         def subscriptions_for(state)
           return {} unless state
 
-          state[:subscriptions].is_a?(Hash) ? state[:subscriptions].dup : {}
+          state.fetch(:subscriptions)
         end
 
         def subscription_state(monitor, profile)
@@ -59,7 +69,7 @@ module Julewire
         def store_subscription_state(monitor, listener:, subscriptions:, profile:)
           subscription_state_store(profile).store(
             monitor,
-            { listener: listener, subscriptions: subscriptions.freeze }.freeze
+            { listener: listener, subscriptions: subscriptions }
           )
         end
 
@@ -96,31 +106,19 @@ module Julewire
         end
 
         def direct_available_events(monitor)
-          return [] unless monitor.respond_to?(:available_events)
-
-          Array(monitor.available_events)
-        rescue StandardError
-          []
+          Array(Core::Integration::Values::Read.value(monitor, :available_events))
         end
 
         def notification_bus_available_events(monitor)
-          return [] unless monitor.respond_to?(:notifications_bus)
+          bus = Core::Integration::Values::Read.value(monitor, :notifications_bus)
 
-          bus = monitor.notifications_bus
-          return [] unless bus.respond_to?(:available_events)
-
-          Array(bus.available_events)
-        rescue StandardError
-          []
+          Array(Core::Integration::Values::Read.value(bus, :available_events))
         end
 
         def listener_event_names(monitor)
-          return [] unless monitor.respond_to?(:listeners)
+          listeners = Core::Integration::Values::Read.value(monitor, :listeners)
 
-          listeners = monitor.listeners
           listeners.is_a?(Hash) ? listeners.keys : []
-        rescue StandardError
-          []
         end
 
         def all_events?(configured)
@@ -131,7 +129,7 @@ module Julewire
           return unless monitor.respond_to?(:unsubscribe)
 
           desired = desired_events.to_h { [it, true] }
-          subscriptions.each_key.to_a.each do |event_name|
+          subscriptions.each_key do |event_name|
             next if desired.key?(event_name)
 
             callback = subscriptions.delete(event_name)
@@ -145,19 +143,9 @@ module Julewire
             component: profile.component,
             event: event_name
           ) do
-            monitor.unsubscribe(callback || event_name)
-            true
+            monitor.unsubscribe(callback)
           end
         end
-
-        def subscribe_event(monitor, event_name, profile, &)
-          return false unless monitor.respond_to?(:subscribe)
-
-          IntegrationHealth.with_failure_health(action: :subscribe, component: profile.component, event: event_name) do
-            monitor.subscribe(event_name, &)
-            true
-          end || false
-        end
       end
     end
 

data/lib/julewire/karafka/version.rb

@@ -2,6 +2,6 @@
 
 module Julewire
   module Karafka
-    VERSION = "1.0.1"
+    VERSION = "1.1.0"
   end
 end

data/lib/julewire/karafka/waterdrop_installer.rb

@@ -6,10 +6,8 @@ module Julewire
       MIDDLEWARE_INSTALL = Core::Integration::IvarState.new(:@julewire_karafka_waterdrop_middleware)
 
       class << self
-        def install!(producer, configuration: Configuration.new)
-          return false unless configuration.enabled?
-
-          install_or_update_middleware(producer, configuration) if middleware_needed?(producer, configuration)
+        def install!(producer, configuration:)
+          install_middleware(producer, configuration) if middleware_needed?(producer, configuration)
           install_listener(producer, configuration) if configuration.producer_events?
           producer
         end
@@ -20,35 +18,32 @@ module Julewire
           configuration.propagation? || installed_middleware(producer)
         end
 
-        def install_or_update_middleware(producer, configuration)
-          install_middleware(producer, configuration)
-        end
-
         def install_middleware(producer, configuration)
           existing = MIDDLEWARE_INSTALL.fetch(producer)
           if existing
             existing.configuration = configuration
-            return existing
+            return
           end
 
-          middleware = producer.middleware if producer.respond_to?(:middleware)
+          return unless producer.respond_to?(:middleware)
+
+          middleware = producer.middleware
           return unless middleware.respond_to?(:prepend)
 
           installed = WaterdropMiddleware.new(configuration: configuration)
           middleware.prepend(installed)
           MIDDLEWARE_INSTALL.store(producer, installed)
-          installed
         rescue StandardError => e
           IntegrationHealth.record_failure(e, action: :install, component: :waterdrop_installer)
-          nil
         end
 
         def install_listener(producer, configuration)
-          monitor = producer.monitor if producer.respond_to?(:monitor)
-          MonitorSubscription.install!(monitor, configuration: configuration, profile: :producer) if monitor
+          return unless producer.respond_to?(:monitor)
+
+          monitor = producer.monitor
+          MonitorSubscription.install!(monitor, configuration: configuration, profile: :producer)
         rescue StandardError => e
           IntegrationHealth.record_failure(e, action: :install, component: :waterdrop_installer)
-          nil
         end
 
         def installed_middleware(producer)

data/lib/julewire/karafka/waterdrop_middleware.rb

@@ -19,7 +19,8 @@ module Julewire
       def inject_carrier(message)
         IntegrationHealth.with_failure_health(action: :carrier_inject, component: :waterdrop_middleware) do
           headers = headers_for(message)
-          Julewire::Core::Propagation::Carrier.inject(
+
+          Core::Propagation::Carrier.inject(
             headers,
             key: @configuration.carrier_key,
             max_bytes: @configuration.carrier_max_bytes
@@ -32,8 +33,6 @@ module Julewire
           message.headers ||= {}
         elsif message.is_a?(Hash)
           message[:headers] ||= {}
-        else
-          {}
         end
       end
     end

data/lib/julewire/karafka.rb

@@ -19,11 +19,12 @@ module Julewire
         return false unless configuration.enabled?
 
         consumer_result = Installer.install!(app: app, monitor: monitor, configuration: configuration) if consumer
-        producer_result = WaterdropInstaller.install!(producer, configuration: configuration) if producer
+        return consumer_result unless producer
 
-        return InstallResult.new(consumer_result, producer_result) if consumer && producer
+        producer_result = WaterdropInstaller.install!(producer, configuration: configuration)
+        return InstallResult.new(consumer_result, producer_result) if consumer
 
-        producer ? producer_result : consumer_result
+        producer_result
       end
 
       def inject!(message, configuration: config)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: julewire-karafka
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Alexander Grebennik
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: karafka
   requirement: !ruby/object:Gem::Requirement
@@ -122,7 +122,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: Karafka and WaterDrop integration for Julewire structured logging.
 test_files: []