eventhub-processor2 1.28.1 → 1.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30f1770bc8368dade5070d56b70f7d178c4f2b9b411b6c8cedc76d5cee74906a
-  data.tar.gz: 437a059f4496b259452423572dc03149dc35dd3992dadf1cf741cf153d76ac44
+  metadata.gz: 84f9fe3b6c2f1eca60c496eb71a647df7f9fc08f4841475cf26b65ff4fc024a6
+  data.tar.gz: ae79889b953ff8af2c9efbd87c396d645fe803153b20a4a56fcc952c64d40214
 SHA512:
-  metadata.gz: e2c36a143e30f630b64756c0a26e2f3d936ef37a34be14eefac20ed105535ec9a2d7c561ec5e482e16ca0df22e484f09d14d3f5ecf202c2d472fbcc5b4588603
-  data.tar.gz: 1e51eb0ae32377c32c2fc5372be3304a276fac5d5df9920658fb804bd8c8461b25a8a9470cccbbc3719963fdfc966e8b9b7f349d7cabb1c9943ddb60ae32cb3e
+  metadata.gz: cdb5378dc754624ec452602fea4eb4cefe7e50e074491d7d48f4d2ae0f7b4fa07839d31e29fecae53c4c2f5836a9010891cd9045e30af4e03e1cdef40892aa4c
+  data.tar.gz: 956bf56d3b193ab891c393b7fa56151b22cdfd31222c4ce66ab6f9d18d9edee860d54eca98cb68264185cf797c71257447dc773ff9006d8d31e8bc94f462e9ff

data/.github/workflows/01_test.yml

@@ -27,7 +27,7 @@ jobs:
 
     name: Ruby ${{ matrix.ruby }}
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v7
 
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1

data/.github/workflows/02_test_build_and_release.yml

@@ -13,7 +13,7 @@ jobs:
       CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
 
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v7
 
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
@@ -41,7 +41,7 @@ jobs:
 
     steps:
     - name: Checkout current code
-      uses: actions/checkout@v6
+      uses: actions/checkout@v7
       with:
         ref: main
 

data/.tool-versions

@@ -1 +1 @@
-ruby 4.0.4
+ruby 4.0.6

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog of EventHub::Processor2
 
+# 1.29.0 / 2026-08-26
+
+* Docs configuration page: sensitive keys now match by substring with an extended default list (e.g. `base_url`, `api_port` are redacted automatically). Exceptions like `vhost` stay visible and can be customized via `non_sensitive_keys`, analogous to `sensitive_keys`. See README for details.
+* Docs configuration page: redaction keeps hash/array structures visible and masks only the scalar values inside.
+* Test coverage raised to 100% lines; removed a dead duplicate route mount in the HTTP listener.
+
+# 1.28.2 / 2026-05-20
+
+* Fix `CorrelationId.current` leaking across messages on the same Bunny consumer thread. `CorrelationId.with` now always saves and restores, even when called with nil/empty. Symptom in production: deadletter messages stamped with an earlier message's `execution_id`.
+* Listener now also resets `correlation_id` after each message (extra safety on top of the fix above, in case some future code writes it outside of `CorrelationId.with`).
+* README: clarify `correlation_id` is the AMQP **property** (envelope-level), not a custom field in the headers table. Producers must set the property; a header named `correlation_id` is invisible to the gem.
+
 # 1.28.1 / 2026-05-19
 
 * Fix `LoggerProxy` double-wrapping when callers pass a Hash to a logger method. Hash inputs are now merged (not nested under `:message`), so the resulting structured event has the caller's fields at the top level - restoring the behaviour that existed before `LoggerProxy` was introduced in 1.26.0, while keeping automatic thread-local injection of `correlation_id` and `execution_id`. Caller-provided values win over thread-locals via `||=`.

data/README.md

@@ -117,6 +117,31 @@ I, [2018-02-09T15:22:35.658522 #37966]  INFO -- : Listener is starting...
 I, [2018-02-09T15:22:35.699161 #37966]  INFO -- : Listening to queue [example]
 ```
 
+## Concurrency Model
+
+Processor2 runs **one consumer thread per queue** listed in `listener_queues`. Each consumer holds a Bunny worker thread with `prefetch(1)`, so it processes its messages sequentially. Multiple queues run their consumers in parallel.
+
+| `listener_queues`             | Concurrency                                    |
+|-------------------------------|------------------------------------------------|
+| `["q1"]`                      | 1 consumer thread, sequential                  |
+| `["q1", "q2"]`                | 2 consumer threads, parallel (one per queue)   |
+| `["q1", "q1", "q1"]`          | 3 consumer threads, all on the same queue      |
+
+To increase throughput for a single queue, either list it multiple times in `listener_queues` (each entry gets its own consumer thread) or run multiple processes. The single-process / single-consumer-per-queue model is what the gem is designed for.
+
+Correlation context (`correlation_id`, `execution_id`) is held in thread-local storage, so concurrent consumer threads cannot interfere with each other - each message's outbound `correlation_id` is the one it received (or its body's fallback), regardless of what other threads are doing.
+
+### A note on `prefetch`
+
+The AMQP `prefetch` value is **fixed at 1** and not currently exposed via configuration. Raising it would require:
+
+- bumping Bunny's `channel.work_pool.size` in lockstep (raising `prefetch` alone only buffers messages in Bunny - it does not add parallelism);
+- pooling or removing `ActorPublisher`'s single-mailbox bottleneck, otherwise N parallel consumers serialize through one publisher;
+- making `handle_message` a thread-safety contract for gem users (today it is implicitly single-threaded - any `@ivar` on the processor class is safe by accident);
+- making `Statistics` and any other shared state thread-safe.
+
+These trade-offs change the gem's call-surface contract, so a configurable `prefetch` would be a minor-version feature, not a patch. For now, the supported way to scale a single queue is to list it multiple times in `listener_queues` or run multiple processes.
+
 ## Logging
 
 By default, Processor2 logs to both stdout (standard format) and a logstash file. For containerized environments (Docker, Kubernetes), use the `--console-log-only` option to output structured JSON logs to stdout only:
@@ -135,10 +160,21 @@ This outputs logs in JSON format suitable for log aggregation systems:
 
 Processor2 supports automatic propagation of correlation IDs for distributed tracing. While EventHub messages already contain an `execution_id` in the message body for tracing, the AMQP `correlation_id` provides an additional benefit: it's part of the message metadata (envelope), not the payload. This means it's available even when the JSON body is invalid and cannot be parsed - useful for error tracking and debugging malformed messages.
 
-When an incoming AMQP message includes a `correlation_id` in its metadata:
+> **Important: `correlation_id` is an AMQP `property`, not a `header`.**
+>
+> In AMQP 0.9.1, `correlation_id` is one of the 14 standard message *properties* (top-level envelope fields, alongside `message_id`, `reply_to`, `content_type`, etc.). The *headers table* is a separate, optional dictionary inside the property block for application-defined fields. They are not interchangeable.
+>
+> Producers must set `correlation_id` as a property. A custom field called `correlation_id` placed inside the headers table is **invisible to this gem** and will silently fall back to the message body's `execution_id`.
+>
+> Concretely:
+> - In Bunny: `channel.default_exchange.publish(payload, correlation_id: "...")`  ✅ property
+> - In Bunny: `... publish(payload, headers: { "correlation_id" => "..." })`  ❌ custom header, not seen
+> - In the RabbitMQ Management UI's "Publish message" form: set the value in the **Properties** section, not in the **Headers** section. When inspecting a queued message, look at "Properties → correlation_id", not at "Headers".
+
+When an incoming AMQP message includes a `correlation_id` in its metadata (as a property):
 
 1. **Automatic logging**: All log messages during message processing will include `correlation_id` as a separate field in structured JSON output
-2. **Automatic publishing**: Any messages published during processing will automatically include the same correlation_id in their AMQP headers
+2. **Automatic publishing**: Any messages published during processing will automatically include the same correlation_id as an AMQP `correlation_id` property (envelope-level, not in the headers table)
 3. **Available in args**: The correlation_id is passed to `handle_message` via `args[:correlation_id]`
 4. **Consistent execution_id**: When creating new messages, `execution_id` is automatically set to match `correlation_id`, ensuring consistent tracing across both AMQP metadata and message body
 
@@ -174,7 +210,7 @@ If no `correlation_id` is present in the AMQP metadata, the message body's `exec
 3. **Stored**: The value is stored in thread-local storage (`Thread.current`) for the duration of message processing
 4. **Passed**: The `correlation_id` is passed to `handle_message` via `args[:correlation_id]`
 5. **Logging**: The logger automatically reads from thread-local storage and includes it in JSON output
-6. **Publishing**: The publisher automatically reads from thread-local storage and adds it to outgoing AMQP message headers (can be overwritten by passing `correlation_id:` explicitly)
+6. **Publishing**: The publisher automatically reads from thread-local storage and sets it as the outgoing AMQP `correlation_id` property (can be overwritten by passing `correlation_id:` explicitly)
 7. **New messages**: When creating a new `EventHub::Message`:
    - With `correlation_id` present → `execution_id` is set to match `correlation_id`
    - Without `correlation_id` → `execution_id` is set to a new UUID (default behavior)
@@ -463,7 +499,7 @@ end
 
 ### Configuration
 
-Displays the active configuration as an HTML table. Sensitive values (passwords, tokens, keys) are automatically redacted at any depth — keys matching the sensitive list are masked whether they appear at the top level, inside nested hashes, or inside hashes nested in arrays.
+Displays the active configuration as an HTML table. Sensitive values (passwords, tokens, keys) are automatically redacted at any depth — keys matching the sensitive list are masked whether they appear at the top level, inside nested hashes, or inside hashes nested in arrays. The structure is always preserved: when a sensitive key holds a hash or array, its keys stay visible and only the scalar values inside are replaced by `***`.
 
 ```
 GET {base_path}/docs/configuration
@@ -471,7 +507,7 @@ GET {base_path}/docs/configuration
 
 **Response:** `200 OK` with HTML page
 
-By default, the following keys are redacted: `password`, `secret`, `token`, `api_key`, `credential`, `username`, `user`, `login`. You can customize the list by defining a `sensitive_keys` method in your processor:
+Matching is by substring: a key is redacted if it *contains* one of the sensitive patterns (case-insensitive). By default, the patterns are: `password`, `secret`, `token`, `api_key`, `credential`, `user`, `login`, `host`, `port`, `database`, `instance`, `url`, `endpoint`, `scheme`. So `base_url`, `api_port`, `username`, or `userpwd` are redacted as well. `vhost` is an explicit exception and stays visible, even though it contains `host`. You can customize the list by defining a `sensitive_keys` method in your processor:
 
 ```ruby
 # Override the entire list
@@ -489,6 +525,17 @@ class MyProcessor < EventHub::Processor2
 end
 ```
 
+Exceptions work the other way around: keys listed as exceptions are never redacted, even if they match a sensitive pattern. Unlike the patterns, exceptions match the whole key exactly (case-insensitive). The default is `vhost`; you can customize the list by defining a `non_sensitive_keys` method:
+
+```ruby
+# Keep username and user visible although they match the user pattern
+class MyProcessor < EventHub::Processor2
+  def non_sensitive_keys
+    EventHub::DocsRenderer::DEFAULT_NON_SENSITIVE_KEYS + %w[username user]
+  end
+end
+```
+
 Or override the entire page by defining a `configuration_as_html` method:
 
 ```ruby

data/eventhub-processor2.gemspec

@@ -32,6 +32,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "rake", "~> 13.2"
   spec.add_development_dependency "rspec", "~> 3.13"
-  spec.add_development_dependency "simplecov", "~> 0.21"
+  spec.add_development_dependency "simplecov", "~> 1.0"
   spec.add_development_dependency "standard", "~> 1.39"
 end

data/lib/eventhub/actor_listener_amqp.rb

@@ -90,6 +90,12 @@ module EventHub
                                  " acknowledged")
           ensure
             ExecutionId.clear
+            # Belt-and-suspenders: CorrelationId.with's ensure already
+            # restores the prior value, but clearing here protects any
+            # future code path that writes CorrelationId.current outside
+            # of `.with` (e.g. handle_payload's fallback was the original
+            # leak source pre-1.28.2).
+            CorrelationId.clear
           end
         end
         queue.subscribe_with(consumer, block: false)

data/lib/eventhub/actor_listener_http.rb

@@ -43,13 +43,12 @@ module EventHub
     end
 
     def mount_resources
-      # Redirect base path to docs
+      # Redirect base path to docs. WEBrick normalizes mount points by
+      # stripping the trailing slash, so this single mount serves both
+      # "#{@base_path}" and "#{@base_path}/".
       @server.mount_proc @base_path do |req, res|
         handle_base_redirect(req, res)
       end
-      @server.mount_proc "#{@base_path}/" do |req, res|
-        handle_base_redirect(req, res)
-      end
 
       # API resources
       @server.mount_proc "#{@base_path}/heartbeat" do |req, res|

data/lib/eventhub/correlation_id.rb

@@ -16,18 +16,20 @@ module EventHub
         Thread.current[:eventhub_correlation_id] = nil
       end
 
-      # Execute block with correlation_id set, ensures cleanup
+      # Execute block with correlation_id set, ensures cleanup.
+      #
+      # Always saves the prior value and restores it on exit, even when
+      # called with nil/empty - otherwise any value written to `current`
+      # inside the block (e.g. handle_payload's fallback to the message
+      # body's execution_id) would leak onto the consumer thread and be
+      # picked up by the next message's processing.
       def with(correlation_id)
-        if correlation_id.nil? || correlation_id.to_s.empty?
+        old_value = current
+        begin
+          self.current = correlation_id unless correlation_id.nil? || correlation_id.to_s.empty?
           yield
-        else
-          old_value = current
-          begin
-            self.current = correlation_id
-            yield
-          ensure
-            self.current = old_value
-          end
+        ensure
+          self.current = old_value
         end
       end
     end

data/lib/eventhub/docs_renderer.rb

@@ -159,29 +159,30 @@ module EventHub
       intro + filter + config_to_html_table(config) + script
     end
 
-    def config_to_html_table(hash, depth = 0, prefix = "")
+    def config_to_html_table(hash, depth = 0, prefix = "", redact: false)
       rows = hash.map do |key, value|
         full_key = prefix.empty? ? key.to_s : "#{prefix}.#{key}"
-        if sensitive_key?(key) && !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
-          "<tr><td class=\"config-key\">#{ERB::Util.html_escape(full_key)}</td><td>#{redacted_html}</td></tr>"
-        elsif depth == 0 && value.is_a?(Hash) && !value.empty?
+        hide = redact || sensitive_key?(key)
+        if depth == 0 && value.is_a?(Hash) && !value.empty?
           "<tr class=\"is-section is-section-top\"><td colspan=\"2\"><strong>#{ERB::Util.html_escape(full_key)}</strong></td></tr>\n" \
-          "#{config_to_html_table(value, 1, full_key)}"
+          "#{config_to_html_table(value, 1, full_key, redact: hide)}"
         elsif value.is_a?(Hash) && value.empty?
           "<tr><td class=\"config-key\">#{ERB::Util.html_escape(full_key)}</td><td><span class=\"not-set\">(empty)</span></td></tr>"
         elsif value.is_a?(Hash) && value.values.all? { |v| v.is_a?(Hash) && v.empty? }
           items = value.keys.map { |k| "<li>#{ERB::Util.html_escape(k)}</li>" }.join("\n")
           "<tr><td class=\"config-key\">#{ERB::Util.html_escape(full_key)}</td><td><ul class=\"config-array\">#{items}</ul></td></tr>"
         elsif value.is_a?(Hash) && compact_hash?(value)
-          "<tr><td class=\"config-key\">#{ERB::Util.html_escape(full_key)}</td><td>#{format_nested_value(value)}</td></tr>"
+          "<tr><td class=\"config-key\">#{ERB::Util.html_escape(full_key)}</td><td>#{format_nested_value(value, redact: hide)}</td></tr>"
         elsif value.is_a?(Hash)
           "<tr class=\"is-section\"><td colspan=\"2\"><strong>#{ERB::Util.html_escape(full_key)}</strong></td></tr>\n" \
-          "#{config_to_html_table(value, depth + 1, full_key)}"
+          "#{config_to_html_table(value, depth + 1, full_key, redact: hide)}"
         elsif value.is_a?(Array)
-          format_array_rows(full_key, key, value, depth)
+          format_array_rows(full_key, value, depth, redact: hide)
         else
           display_value = if value.nil? || value.to_s.strip.empty?
             "<span class=\"not-set\">(not set)</span>"
+          elsif hide
+            redacted_html
           else
             ERB::Util.html_escape(value.to_s)
           end
@@ -196,44 +197,42 @@ module EventHub
       end
     end
 
-    def format_array_rows(full_key, key, array, _depth)
+    def format_array_rows(full_key, array, _depth, redact: false)
       return "<tr><td class=\"config-key\">#{ERB::Util.html_escape(full_key)}</td><td><span class=\"not-set\">(empty)</span></td></tr>" if array.empty?
 
-      if sensitive_key?(key)
-        return "<tr><td class=\"config-key\">#{ERB::Util.html_escape(full_key)}</td><td>#{redacted_html}</td></tr>"
-      end
-
-      inner = array.map { |item| format_array_item(item) }.join("\n")
+      inner = array.map { |item| format_array_item(item, redact: redact) }.join("\n")
       "<tr><td class=\"config-key\">#{ERB::Util.html_escape(full_key)}</td><td><ul class=\"config-array\">#{inner}</ul></td></tr>"
     end
 
-    def format_array_item(item)
+    def format_array_item(item, redact: false)
       if item.is_a?(Hash)
         rows = item.map do |k, v|
-          value = sensitive_key?(k) ? redacted_html : format_nested_value(v)
-          "<tr><td>#{ERB::Util.html_escape(k)}</td><td>#{value}</td></tr>"
+          hide = redact || sensitive_key?(k)
+          "<tr><td>#{ERB::Util.html_escape(k)}</td><td>#{format_nested_value(v, redact: hide)}</td></tr>"
         end.join
         "<li><table class=\"table is-bordered is-narrow config-subtable\">#{rows}</table></li>"
       elsif item.is_a?(Array)
-        inner = item.map { |i| format_array_item(i) }.join("\n")
+        inner = item.map { |i| format_array_item(i, redact: redact) }.join("\n")
         "<li><ul class=\"config-array\">#{inner}</ul></li>"
       else
-        "<li>#{ERB::Util.html_escape(item.to_s)}</li>"
+        "<li>#{redact ? redacted_html : ERB::Util.html_escape(item.to_s)}</li>"
       end
     end
 
-    def format_nested_value(value)
+    def format_nested_value(value, redact: false)
       if value.is_a?(Hash)
         rows = value.map do |k, v|
-          inner = sensitive_key?(k) ? redacted_html : format_nested_value(v)
-          "<tr><td>#{ERB::Util.html_escape(k)}</td><td>#{inner}</td></tr>"
+          hide = redact || sensitive_key?(k)
+          "<tr><td>#{ERB::Util.html_escape(k)}</td><td>#{format_nested_value(v, redact: hide)}</td></tr>"
         end.join
         "<table class=\"table is-bordered is-narrow config-subtable\">#{rows}</table>"
       elsif value.is_a?(Array)
-        items = value.map { |i| format_array_item(i) }.join("\n")
+        items = value.map { |i| format_array_item(i, redact: redact) }.join("\n")
         "<ul class=\"config-array\">#{items}</ul>"
       elsif value.nil? || value.to_s.strip.empty?
         "<span class=\"not-set\">(not set)</span>"
+      elsif redact
+        redacted_html
       else
         ERB::Util.html_escape(value.to_s)
       end
@@ -253,15 +252,27 @@ module EventHub
       end
     end
 
-    DEFAULT_SENSITIVE_KEYS = %w[password secret token api_key credential username user login].freeze
+    DEFAULT_SENSITIVE_KEYS = %w[password secret token api_key credential user login host port database instance url endpoint scheme].freeze
+    DEFAULT_NON_SENSITIVE_KEYS = %w[vhost].freeze
 
     def sensitive_key?(key)
+      normalized = key.to_s.downcase
+      return false if non_sensitive_keys.any? { |exception| normalized == exception.downcase }
+
       keys = if @processor&.class&.method_defined?(:sensitive_keys)
         @processor.sensitive_keys
       else
         DEFAULT_SENSITIVE_KEYS
       end
-      keys.any? { |pattern| key.to_s.downcase == pattern.downcase }
+      keys.any? { |pattern| normalized.include?(pattern.downcase) }
+    end
+
+    def non_sensitive_keys
+      if @processor&.class&.method_defined?(:non_sensitive_keys)
+        @processor.non_sensitive_keys
+      else
+        DEFAULT_NON_SENSITIVE_KEYS
+      end
     end
 
     def markdown_to_html(markdown)

data/lib/eventhub/version.rb

@@ -1,3 +1,3 @@
 module EventHub
-  VERSION = "1.28.1".freeze
+  VERSION = "1.29.0".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eventhub-processor2
 version: !ruby/object:Gem::Version
-  version: 1.28.1
+  version: 1.29.0
 platform: ruby
 authors:
 - Steiner, Thomas
@@ -141,14 +141,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: standard
   requirement: !ruby/object:Gem::Requirement
@@ -247,7 +247,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Next generation gem to build ruby based eventhub processor
 test_files: []