easyop 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f110ef0a50149ab84f49b40209a05bbf152a995b802a8664c59ff95f0eb36ee1
-  data.tar.gz: d35940933ad93ca75eba984ed9a83cad28045ba3492e6745bda41d4c95154ec5
+  metadata.gz: 4c77d9aa5925ea30b3de85fc74618f355ee3498223f79d6184cda21e95574b8d
+  data.tar.gz: 8bd775d8fa095a50b46aafeedec78f2046d54005b6316a1f22ae02b5657c361c
 SHA512:
-  metadata.gz: 47f9214496757ec818887f4d9372d03b3e4d26c488927de696637212d1b3aef42f3fcefda00fff85aa6f6452a4e93ecbbd674f859f38fda974b7b77bead059ff
-  data.tar.gz: 5544728ce871c2eac2b9dfe6dfc278cc0c4f3cbe38f648ce031d82a55f16eb3400b29c34a883092a5167d07284beadc061ab6ab54eaac695cb5a87f6d8486d84
+  metadata.gz: a01be26e27050c1569f85ee610043ca42268c75054355c4faf230b65599354d9a824b07955f4f13cda25672681d1c934bbeaec15d89be2cfd8ad55681dd29511
+  data.tar.gz: 41d8d5bf9ca01e02146764678c343eac787c2d5445670caa9e8c1a0f0b60ff26b57906f2fb4abd16b7e59d05b05fe65a1400cff4458934df0110bf1af10f5d3a

data/CHANGELOG.md

@@ -7,6 +7,163 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.3] — 2026-04-14
+
+### Added
+
+- **Minitest test suite** — a full parallel test suite covering all 21 modules in the gem. Tests live in `test/` and run via `bundle exec rake test` (or `bundle exec ruby -Ilib:test ...`). The suite complements the existing RSpec specs and is tracked as a separate SimpleCov report (command name `'Minitest'`).
+
+  Coverage across 258 tests, 360 assertions:
+
+  | Area | Files |
+  |------|-------|
+  | Core | `ctx_test`, `operation_test`, `hooks_test`, `rescuable_test`, `schema_test`, `skip_test`, `flow_test`, `flow_builder_test` |
+  | Events infrastructure | `events/event_test`, `events/registry_test`, `events/bus/memory_test`, `events/bus/adapter_test`, `events/bus/custom_test`, `events/bus/active_support_notifications_test` |
+  | Plugins | `plugins/base_test`, `plugins/recording_test`, `plugins/instrumentation_test`, `plugins/async_test`, `plugins/transactional_test`, `plugins/events_test`, `plugins/event_handlers_test` |
+
+  Key test patterns: anonymous `Class.new` operations, `set_const` helper for named-constant scenarios (Recording, Async), shared stubs for `ActiveSupport::Notifications`, `ActiveRecord::Base`, `ActiveJob::Base`, and `String#constantize` — all in `test/test_helper.rb` so individual files stay focused.
+
+- **`Rakefile`** — adds a `test` task (Minitest) as the default Rake task:
+
+  ```ruby
+  bundle exec rake test
+  # or simply:
+  bundle exec rake
+  ```
+
+- **`rake` gem** added to the `development/test` group in `Gemfile`.
+
+- **`Easyop::Events::Bus::Adapter`** — a new inheritable base class for custom bus implementations. Subclass this instead of `Bus::Base` when building a transport adapter (RabbitMQ, Kafka, Redis, etc.). Provides two protected utilities on top of `Bus::Base`:
+
+  - `_safe_invoke(handler, event)` — calls `handler.call(event)` and rescues `StandardError`, so one broken subscriber never prevents others from running
+  - `_compile_pattern(pattern)` — converts a glob string or exact string to a `Regexp`, memoized per unique pattern per bus instance (glob→Regexp conversion happens only once regardless of publish volume)
+
+  ```ruby
+  require "easyop/events/bus/adapter"
+
+  # Decorator: wrap any inner bus and add structured logging
+  class LoggingBus < Easyop::Events::Bus::Adapter
+    def initialize(inner = Easyop::Events::Bus::Memory.new)
+      super(); @inner = inner
+    end
+
+    def publish(event)
+      Rails.logger.info "[bus] #{event.name} payload=#{event.payload}"
+      @inner.publish(event)
+    end
+
+    def subscribe(pattern, &block) = @inner.subscribe(pattern, &block)
+    def unsubscribe(handle)        = @inner.unsubscribe(handle)
+  end
+
+  Easyop::Events::Registry.bus = LoggingBus.new
+
+  # Full external broker example — RabbitMQ via Bunny gem:
+  class RabbitBus < Easyop::Events::Bus::Adapter
+    EXCHANGE_NAME = "easyop.events"
+    def initialize(url = ENV.fetch("AMQP_URL")) = (super(); @url = url)
+    def publish(event)
+      exchange.publish(event.to_h.to_json, routing_key: event.name)
+    end
+    def subscribe(pattern, &block)
+      q = channel.queue("", exclusive: true, auto_delete: true)
+      q.bind(exchange, routing_key: pattern.gsub("**", "#"))
+      q.subscribe { |_, _, body| _safe_invoke(block, decode(body)) }
+    end
+    private
+    def decode(body) = Easyop::Events::Event.new(**JSON.parse(body, symbolize_names: true))
+    def connection   = @conn ||= Bunny.new(@url).tap(&:start)
+    def channel      = @ch   ||= connection.create_channel
+    def exchange     = @exch ||= channel.topic(EXCHANGE_NAME, durable: true)
+  end
+  ```
+
+- **`Plugins::Events`** — a new producer plugin that emits domain events after an operation completes. Install on any operation class and declare events with the `emits` DSL:
+
+  ```ruby
+  class PlaceOrder < ApplicationOperation
+    plugin Easyop::Plugins::Events
+
+    emits "order.placed", on: :success, payload: [:order_id, :total]
+    emits "order.failed", on: :failure, payload: ->(ctx) { { error: ctx.error } }
+    emits "order.attempted", on: :always
+  end
+  ```
+
+  Options for `emits`: `on:` (`:success` / `:failure` / `:always`), `payload:` (Proc, Array of ctx keys, or nil for full ctx), `guard:` (optional Proc condition). Events fire in an `ensure` block so they are published even when `call!` raises `Ctx::Failure`. Individual publish failures are swallowed and never crash the operation. Subclasses inherit parent declarations.
+
+- **`Plugins::EventHandlers`** — a new subscriber plugin that wires an operation as a domain event handler:
+
+  ```ruby
+  class SendConfirmation < ApplicationOperation
+    plugin Easyop::Plugins::EventHandlers
+
+    on "order.placed"
+
+    def call
+      OrderMailer.confirm(ctx.order_id).deliver_later
+    end
+  end
+
+  # Async dispatch (requires Plugins::Async also installed):
+  class IndexOrder < ApplicationOperation
+    plugin Easyop::Plugins::Async, queue: "indexing"
+    plugin Easyop::Plugins::EventHandlers
+
+    on "order.*",      async: true
+    on "inventory.**", async: true, queue: "low"
+
+    def call
+      SearchIndex.reindex(ctx.order_id)
+    end
+  end
+  ```
+
+  Supports glob patterns: `"order.*"` matches within one segment; `"order.**"` matches across segments. Registration happens at class-load time. Handler operations receive `ctx.event` (the `Easyop::Events::Event` object) and payload keys merged into ctx.
+
+- **`Easyop::Events::Event`** — immutable, frozen domain event value object. Carries `name`, `payload`, `source` (emitting class name), `metadata`, and `timestamp`. Serializable to a plain Hash via `#to_h`.
+
+- **`Easyop::Events::Bus`** — pluggable bus adapter system with three built-in adapters:
+  - `Bus::Memory` — in-process synchronous bus (default). Thread-safe via Mutex. Supports glob patterns and Regexp subscriptions. Test-friendly: `clear!`, `subscriber_count`.
+  - `Bus::ActiveSupportNotifications` — wraps `ActiveSupport::Notifications`. Lazy-checks for the library.
+  - `Bus::Custom` — wraps any user object responding to `#publish` and `#subscribe`. Validates the interface at construction time.
+
+- **`Easyop::Events::Registry`** — thread-safe global coordination point. Configure once at boot; handler subscriptions are registered against it at class-load time:
+
+  ```ruby
+  # Globally:
+  Easyop::Events::Registry.bus = :memory           # default
+  Easyop::Events::Registry.bus = :active_support
+  Easyop::Events::Registry.bus = MyRabbitBus.new   # custom adapter
+
+  # Or via config:
+  Easyop.configure { |c| c.event_bus = :active_support }
+  ```
+
+- **`Easyop::Configuration#event_bus`** — new configuration key. Accepts `:memory`, `:active_support`, or a bus adapter instance.
+
+## [0.1.2] — 2026-04-13
+
+### Added
+
+- **`Plugins::Async` — `queue` DSL** — a new `queue` class method for declaring the default queue directly on an operation class (or a shared base class). This lets subclasses override the queue set at plugin install time without re-declaring the plugin:
+
+  ```ruby
+  class Weather::BaseOperation < ApplicationOperation
+    queue :weather   # all Weather ops use the "weather" queue
+  end
+
+  class Weather::FetchForecast < Weather::BaseOperation
+    # inherits queue :weather automatically
+  end
+
+  class Weather::CleanupExpiredDays < Weather::BaseOperation
+    queue :low_priority   # override just for this class
+  end
+  ```
+
+  Accepts both `Symbol` and `String`. The setting is inherited by subclasses and can be overridden at any level of the hierarchy.
+
 ## [0.1.1] — 2026-04-01
 
 ### Fixed
@@ -43,6 +200,5 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `examples/easyop_test_app/` — full Rails 8 blog application demonstrating all features in real-world code
 - `examples/usage.rb` — 13 runnable plain-Ruby examples
 
-[Unreleased]: https://github.com/pniemczyk/easyop/compare/v0.1.1...HEAD
-[0.1.1]: https://github.com/pniemczyk/easyop/compare/v0.1.0...v0.1.1
-[0.1.0]: https://github.com/pniemczyk/easyop/releases/tag/v0.1.0
+[Unreleased]: https://github.com/pniemczyk/easyop/compare/v0.1.2...HEAD
+[0.1.3]: https://github.com/pniemczyk/easyop/compare/v0.1.2...v0.1.3

data/README.md

@@ -672,6 +672,20 @@ Newsletter::SendBroadcast.call_async(attrs, wait_until: Date.tomorrow.noon)
 Newsletter::SendBroadcast.call_async(attrs, queue: "low_priority")
 ```
 
+**`queue` DSL** — declare the default queue directly on a class (or a shared base class) instead of at plugin install time:
+
+```ruby
+class Weather::BaseOperation < ApplicationOperation
+  queue :weather   # all Weather ops use the "weather" queue by default
+end
+
+class Weather::CleanupExpiredDays < Weather::BaseOperation
+  queue :low_priority   # override just for this class
+end
+```
+
+The `queue` setting is inherited by subclasses and can be overridden at any level. Accepts `Symbol` or `String`. A per-call `queue:` argument to `.call_async` always takes precedence.
+
 **ActiveRecord objects** are serialized by `(class, id)` and re-fetched in the job:
 
 ```ruby
@@ -685,6 +699,198 @@ The plugin defines `Easyop::Plugins::Async::Job` lazily (on first call to `.call
 
 ---
 
+### Plugin: Events
+
+Emits domain events after an operation completes. Unlike the Instrumentation plugin (which is for operation-level tracing), Events carries business domain events through a configurable bus.
+
+```ruby
+require "easyop/events/event"
+require "easyop/events/bus"
+require "easyop/events/bus/memory"
+require "easyop/events/registry"
+require "easyop/plugins/events"
+require "easyop/plugins/event_handlers"
+
+class PlaceOrder < ApplicationOperation
+  plugin Easyop::Plugins::Events
+
+  emits "order.placed", on: :success, payload: [:order_id, :total]
+  emits "order.failed", on: :failure, payload: ->(ctx) { { error: ctx.error } }
+  emits "order.attempted", on: :always
+
+  def call
+    ctx.order_id = Order.create!(ctx.to_h).id
+  end
+end
+```
+
+**`emits` DSL options:**
+
+| Option | Values | Default | Description |
+|---|---|---|---|
+| `on:` | `:success`, `:failure`, `:always` | `:success` | When to fire |
+| `payload:` | `Proc`, `Array`, `nil` | `nil` (full ctx) | Proc receives ctx; Array slices ctx keys |
+| `guard:` | `Proc`, `nil` | `nil` | Extra condition — fires only when truthy |
+
+Events fire in an `ensure` block and are emitted even when `call!` raises. Individual publish failures are swallowed and never crash the operation. `emits` declarations are inherited by subclasses.
+
+---
+
+### Plugin: EventHandlers
+
+Wires an operation class as a domain event handler. Handler operations receive `ctx.event` (the `Easyop::Events::Event` object) and all payload keys merged into ctx.
+
+```ruby
+class SendConfirmation < ApplicationOperation
+  plugin Easyop::Plugins::EventHandlers
+
+  on "order.placed"
+
+  def call
+    event    = ctx.event      # Easyop::Events::Event
+    order_id = ctx.order_id   # payload keys merged into ctx
+    OrderMailer.confirm(order_id).deliver_later
+  end
+end
+```
+
+**Async dispatch** (requires `Plugins::Async` also installed):
+
+```ruby
+class IndexOrder < ApplicationOperation
+  plugin Easyop::Plugins::Async, queue: "indexing"
+  plugin Easyop::Plugins::EventHandlers
+
+  on "order.*",      async: true
+  on "inventory.**", async: true, queue: "low"
+
+  def call
+    # ctx.event_data is a Hash when dispatched async (serializable for ActiveJob)
+    SearchIndex.reindex(ctx.order_id)
+  end
+end
+```
+
+**Glob patterns:**
+- `"order.*"` — matches within one dot-segment (`order.placed`, `order.shipped`)
+- `"warehouse.**"` — matches across segments (`warehouse.stock.updated`, `warehouse.zone.moved`)
+- Plain strings match exactly; `Regexp` is also accepted
+
+Registration happens at class-load time. Configure the bus **before** loading handler classes.
+
+---
+
+### Events Bus — Configurable Transport
+
+The bus adapter controls how events are delivered. Configure it once at boot:
+
+```ruby
+# Default — in-process synchronous (great for tests and simple setups)
+Easyop::Events::Registry.bus = :memory
+
+# ActiveSupport::Notifications (integrates with Rails instrumentation)
+Easyop::Events::Registry.bus = :active_support
+
+# Any custom adapter (RabbitMQ, Kafka, Redis Pub/Sub…)
+Easyop::Events::Registry.bus = MyRabbitBus.new
+
+# Or via config block:
+Easyop.configure { |c| c.event_bus = :active_support }
+```
+
+**Built-in adapters:**
+
+| Adapter | Class | Notes |
+|---|---|---|
+| Memory | `Easyop::Events::Bus::Memory` | Default. Thread-safe, in-process, synchronous. |
+| ActiveSupport | `Easyop::Events::Bus::ActiveSupportNotifications` | Wraps `AS::Notifications`. Requires `activesupport`. |
+| Custom | `Easyop::Events::Bus::Custom` | Wraps any object with `#publish` and `#subscribe`. |
+
+**Building a custom bus — two approaches:**
+
+**Option A — subclass `Bus::Adapter`** (recommended for real transports). Inherits glob helpers, `_safe_invoke`, and `_compile_pattern`:
+
+```ruby
+require "easyop/events/bus/adapter"
+
+# Decorator: wraps any inner bus and adds structured logging
+class LoggingBus < Easyop::Events::Bus::Adapter
+  def initialize(inner = Easyop::Events::Bus::Memory.new)
+    super()
+    @inner = inner
+  end
+
+  def publish(event)
+    Rails.logger.info "[bus:publish] #{event.name} payload=#{event.payload}"
+    @inner.publish(event)
+  end
+
+  def subscribe(pattern, &block) = @inner.subscribe(pattern, &block)
+  def unsubscribe(handle)        = @inner.unsubscribe(handle)
+end
+
+Easyop::Events::Registry.bus = LoggingBus.new
+
+# Full RabbitMQ example (Bunny gem) — uses _safe_invoke for handler safety:
+class RabbitBus < Easyop::Events::Bus::Adapter
+  EXCHANGE_NAME = "easyop.events"
+
+  def initialize(url = ENV.fetch("AMQP_URL", "amqp://localhost"))
+    super()
+    @url = url; @mutex = Mutex.new; @handles = {}
+  end
+
+  def publish(event)
+    exchange.publish(event.to_h.to_json,
+                     routing_key: event.name, content_type: "application/json")
+  end
+
+  def subscribe(pattern, &block)
+    q = channel.queue("", exclusive: true, auto_delete: true)
+    q.bind(exchange, routing_key: _to_amqp(pattern))
+    consumer = q.subscribe { |_, _, body| _safe_invoke(block, decode(body)) }
+    handle = Object.new
+    @mutex.synchronize { @handles[handle.object_id] = { queue: q, consumer: consumer } }
+    handle
+  end
+
+  def unsubscribe(handle)
+    @mutex.synchronize do
+      e = @handles.delete(handle.object_id); return unless e
+      e[:consumer].cancel; e[:queue].delete
+    end
+  end
+
+  def disconnect
+    @mutex.synchronize { @connection&.close; @connection = @channel = @exchange = nil }
+  end
+
+  private
+
+  def _to_amqp(p)  = p.is_a?(Regexp) ? p.source : p.gsub("**", "#")
+  def decode(body) = Easyop::Events::Event.new(**JSON.parse(body, symbolize_names: true))
+  def connection   = @connection ||= Bunny.new(@url, recover_from_connection_close: true).tap(&:start)
+  def channel      = @channel    ||= connection.create_channel
+  def exchange     = @exchange   ||= channel.topic(EXCHANGE_NAME, durable: true)
+end
+
+Easyop::Events::Registry.bus = RabbitBus.new
+at_exit { Easyop::Events::Registry.bus.disconnect }
+```
+
+**Option B — duck-typed object** (no subclassing). Pass any object with `#publish` and `#subscribe`; Registry auto-wraps it in `Bus::Custom`:
+
+```ruby
+class MyKafkaBus
+  def publish(event) = Kafka.produce(event.name, event.to_h.to_json)
+  def subscribe(pattern, &block) = Kafka.subscribe(pattern) { |msg| block.call(decode(msg)) }
+end
+
+Easyop::Events::Registry.bus = MyKafkaBus.new
+```
+
+---
+
 ### Plugin: Transactional
 
 Wraps every operation call in a database transaction. On `ctx.fail!` or any unhandled exception the transaction is rolled back. Supports **ActiveRecord** and **Sequel**.
@@ -1108,3 +1314,84 @@ See the **[AI Tools docs page](https://pniemczyk.github.io/easyop/ai-tools.html)
 | `Easyop::Plugins::Async` | `easyop/plugins/async` | Adds `.call_async` via ActiveJob with AR object serialization |
 | `Easyop::Plugins::Async::Job` | (created lazily) | The ActiveJob class that deserializes and runs the operation |
 | `Easyop::Plugins::Transactional` | `easyop/plugins/transactional` | Wraps operation in an AR/Sequel transaction; `transactional false` to opt out |
+| `Easyop::Plugins::Events` | `easyop/plugins/events` | Emits domain events after execution; `emits` DSL with `on:`, `payload:`, `guard:` |
+| `Easyop::Plugins::EventHandlers` | `easyop/plugins/event_handlers` | Subscribes an operation to handle domain events; `on` DSL with glob patterns |
+
+### Domain Events Infrastructure
+
+| Class/Module | Require | Description |
+|---|---|---|
+| `Easyop::Events::Event` | `easyop/events/event` | Immutable frozen value object: `name`, `payload`, `metadata`, `timestamp`, `source` |
+| `Easyop::Events::Bus::Base` | `easyop/events/bus` | Abstract adapter interface (`publish`, `subscribe`, `unsubscribe`) and glob helpers |
+| `Easyop::Events::Bus::Adapter` | `easyop/events/bus/adapter` | **Inheritable base for custom buses.** Adds `_safe_invoke` + `_compile_pattern` (memoized). Subclass this. |
+| `Easyop::Events::Bus::Memory` | `easyop/events/bus/memory` | In-process synchronous bus (default). Thread-safe. |
+| `Easyop::Events::Bus::ActiveSupportNotifications` | `easyop/events/bus/active_support_notifications` | `ActiveSupport::Notifications` adapter |
+| `Easyop::Events::Bus::Custom` | `easyop/events/bus/custom` | Wraps any user-provided bus object (duck-typed, no subclassing needed) |
+| `Easyop::Events::Registry` | `easyop/events/registry` | Global bus holder + handler subscription registry |
+
+---
+
+## Releasing a New Version
+
+Follow these steps to bump the version, update the changelog, and publish a tagged release.
+
+### 1. Bump the version number
+
+Edit `lib/easyop/version.rb` and increment the version string following [Semantic Versioning](https://semver.org/):
+
+```ruby
+# lib/easyop/version.rb
+module Easyop
+  VERSION = "0.1.4"   # was 0.1.3
+end
+```
+
+### 2. Update the changelog
+
+In `CHANGELOG.md`, move everything under `[Unreleased]` into a new versioned section:
+
+```markdown
+## [Unreleased]
+
+## [0.1.4] — YYYY-MM-DD   # ← new section
+
+### Added
+- …
+
+## [0.1.3] — 2026-04-14
+```
+
+Add a comparison link at the bottom of the file:
+
+```markdown
+[Unreleased]: https://github.com/pniemczyk/easyop/compare/v0.1.4...HEAD
+[0.1.4]: https://github.com/pniemczyk/easyop/compare/v0.1.3...v0.1.4
+[0.1.3]: https://github.com/pniemczyk/easyop/compare/v0.1.2...v0.1.3
+```
+
+### 3. Commit the release changes
+
+```bash
+git add lib/easyop/version.rb CHANGELOG.md
+git commit -m "Release v0.1.4"
+```
+
+### 4. Tag the commit
+
+```bash
+git tag -a v0.1.4 -m "Release v0.1.4"
+```
+
+### 5. Push the commit and tag
+
+```bash
+git push origin master
+git push origin v0.1.4
+```
+
+### 6. Build and push the gem (optional)
+
+```bash
+gem build easyop.gemspec
+gem push easyop-0.1.4.gem
+```

data/lib/easyop/configuration.rb

@@ -8,9 +8,17 @@ module Easyop
     # When false (default), mismatches emit a warning and execution continues.
     attr_accessor :strict_types
 
+    # Bus adapter for domain events (Easyop::Plugins::Events / EventHandlers).
+    # Options: :memory (default), :active_support, or a bus adapter instance.
+    #
+    # @example
+    #   Easyop.configure { |c| c.event_bus = :active_support }
+    attr_accessor :event_bus
+
     def initialize
       @type_adapter = :native
       @strict_types = false
+      @event_bus    = nil  # nil = Memory bus (see Easyop::Events::Registry)
     end
   end
 

data/lib/easyop/events/bus/active_support_notifications.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Easyop
+  module Events
+    module Bus
+      # Bus adapter backed by ActiveSupport::Notifications.
+      #
+      # Requires activesupport (not auto-required). Raises LoadError if unavailable.
+      #
+      # @example
+      #   Easyop::Events::Registry.bus = :active_support
+      #
+      #   # or manually:
+      #   bus = Easyop::Events::Bus::ActiveSupportNotifications.new
+      #   Easyop::Events::Registry.bus = bus
+      class ActiveSupportNotifications < Base
+        # Publish +event+ via ActiveSupport::Notifications.instrument.
+        # The full event hash (name, payload, metadata, timestamp, source) is passed
+        # as the AS notification payload.
+        #
+        # @param event [Easyop::Events::Event]
+        def publish(event)
+          _ensure_as!
+          ::ActiveSupport::Notifications.instrument(event.name, event.to_h)
+        end
+
+        # Subscribe to events matching +pattern+ via ActiveSupport::Notifications.subscribe.
+        # Glob patterns are converted to Regexp before passing to AS.
+        #
+        # @param pattern [String, Regexp]
+        # @return [Object] AS subscription handle
+        def subscribe(pattern, &block)
+          _ensure_as!
+
+          as_pattern = _as_pattern(pattern)
+
+          ::ActiveSupport::Notifications.subscribe(as_pattern) do |*args|
+            as_event     = ::ActiveSupport::Notifications::Event.new(*args)
+            p            = as_event.payload
+
+            # Reconstruct an Easyop::Events::Event from the AS notification payload.
+            easyop_event = Event.new(
+              name:      (p[:name] || as_event.name).to_s,
+              payload:   p[:payload]  || {},
+              metadata:  p[:metadata] || {},
+              timestamp: p[:timestamp],
+              source:    p[:source]
+            )
+            block.call(easyop_event)
+          end
+        end
+
+        # Unsubscribe using the handle returned by #subscribe.
+        # @param handle [Object] AS subscription object
+        def unsubscribe(handle)
+          _ensure_as!
+          ::ActiveSupport::Notifications.unsubscribe(handle)
+        end
+
+        private
+
+        # Convert a pattern for use with AS::Notifications.subscribe.
+        # AS accepts exact strings or Regexp (not globs), so convert globs first.
+        def _as_pattern(pattern)
+          case pattern
+          when Regexp then pattern
+          when String
+            pattern.include?("*") ? _glob_to_regex(pattern) : pattern
+          end
+        end
+
+        def _ensure_as!
+          return if defined?(::ActiveSupport::Notifications)
+
+          raise LoadError,
+            "ActiveSupport::Notifications is required for this bus adapter. " \
+            "Add 'activesupport' to your Gemfile."
+        end
+      end
+    end
+  end
+end