easyop 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9157dccd94c6847b4b83c01404b64d48ffe54f1f6f51a99e0263bb718a2acdc4
-  data.tar.gz: 62bbaa697722e2b0d1979bc5a20839fb9dc765ee22d989f404591129a8a72c01
+  metadata.gz: 4c77d9aa5925ea30b3de85fc74618f355ee3498223f79d6184cda21e95574b8d
+  data.tar.gz: 8bd775d8fa095a50b46aafeedec78f2046d54005b6316a1f22ae02b5657c361c
 SHA512:
-  metadata.gz: 52fc250d99c11808462344afb74603081aa2dd35ca4f4d16ec263d19b3c098bba77ddcdda7963793483a9bfc0b04bd2cf63a70700c9756e0fb6b4610229ecc9f
-  data.tar.gz: 778348d6dc863bdda5816a32738ae2262c3948eb3711090b0a4412bc0678a9dc9b7c87e48cd937c3f1842e492f5be787c252c42f8ae9955191794cc9200dfc1e
+  metadata.gz: a01be26e27050c1569f85ee610043ca42268c75054355c4faf230b65599354d9a824b07955f4f13cda25672681d1c934bbeaec15d89be2cfd8ad55681dd29511
+  data.tar.gz: 41d8d5bf9ca01e02146764678c343eac787c2d5445670caa9e8c1a0f0b60ff26b57906f2fb4abd16b7e59d05b05fe65a1400cff4458934df0110bf1af10f5d3a

data/CHANGELOG.md

@@ -7,6 +7,141 @@ 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
@@ -66,6 +201,4 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `examples/usage.rb` — 13 runnable plain-Ruby examples
 
 [Unreleased]: https://github.com/pniemczyk/easyop/compare/v0.1.2...HEAD
-[0.1.2]: https://github.com/pniemczyk/easyop/compare/v0.1.1...v0.1.2
-[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
+[0.1.3]: https://github.com/pniemczyk/easyop/compare/v0.1.2...v0.1.3

data/README.md

@@ -699,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**.
@@ -1122,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

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Easyop
+  module Events
+    module Bus
+      # Inheritable base class for custom bus implementations.
+      #
+      # Subclass this (not +Bus::Base+) when building a transport adapter for
+      # an external message broker, pub/sub system, or any custom delivery
+      # mechanism. +Bus::Base+ defines the required interface and glob helpers.
+      # +Bus::Adapter+ adds two production-grade utilities on top:
+      #
+      #   _safe_invoke(handler, event)   — call a handler, swallow StandardError
+      #   _compile_pattern(pattern)      — glob/string → cached Regexp
+      #
+      # Both are protected so they are accessible in subclasses but not part
+      # of the external bus interface.
+      #
+      # == Minimum contract
+      #
+      # Override +#publish+ and +#subscribe+. Override +#unsubscribe+ if your
+      # transport supports subscription cancellation.
+      #
+      # == Example — minimal adapter
+      #
+      #   class PrintBus < Easyop::Events::Bus::Adapter
+      #     def initialize
+      #       super
+      #       @subs  = []
+      #       @mutex = Mutex.new
+      #     end
+      #
+      #     def publish(event)
+      #       snap = @mutex.synchronize { @subs.dup }
+      #       snap.each do |sub|
+      #         _safe_invoke(sub[:handler], event) if _pattern_matches?(sub[:pattern], event.name)
+      #       end
+      #     end
+      #
+      #     def subscribe(pattern, &block)
+      #       handle = { pattern: _compile_pattern(pattern), handler: block }
+      #       @mutex.synchronize { @subs << handle }
+      #       handle
+      #     end
+      #
+      #     def unsubscribe(handle)
+      #       @mutex.synchronize { @subs.delete(handle) }
+      #     end
+      #   end
+      #
+      # == Example — decorator (wraps another bus)
+      #
+      #   class LoggingBus < Easyop::Events::Bus::Adapter
+      #     def initialize(inner)
+      #       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)
+      #     end
+      #
+      #     def unsubscribe(handle)
+      #       @inner.unsubscribe(handle)
+      #     end
+      #   end
+      #
+      #   Easyop::Events::Registry.bus = LoggingBus.new(Easyop::Events::Bus::Memory.new)
+      class Adapter < Base
+        protected
+
+        # Call +handler+ with +event+, rescuing any StandardError.
+        #
+        # Use this inside your +#publish+ implementation so one broken handler
+        # never prevents other handlers from running and never surfaces an
+        # exception to the event producer.
+        #
+        # @param handler [#call]
+        # @param event   [Easyop::Events::Event]
+        # @return [void]
+        def _safe_invoke(handler, event)
+          handler.call(event)
+        rescue StandardError
+          # Intentionally swallowed — individual handler failures must not
+          # propagate to the caller or block remaining handlers.
+        end
+
+        # Compile +pattern+ into a +Regexp+, memoized per unique pattern value.
+        #
+        # Results are cached in a per-instance hash so glob→Regexp conversion
+        # happens only once regardless of how many events are published.
+        #
+        # String patterns without wildcards are anchored literally.
+        # Glob patterns follow the same rules as +Bus::Base#_glob_to_regex+:
+        #   "*"  — any single dot-separated segment
+        #   "**" — any sequence of characters including dots
+        #
+        # @param pattern [String, Regexp]
+        # @return [Regexp]
+        def _compile_pattern(pattern)
+          return pattern if pattern.is_a?(Regexp)
+
+          @_pattern_cache ||= {}
+          @_pattern_cache[pattern] ||=
+            if pattern.include?("*")
+              _glob_to_regex(pattern)
+            else
+              Regexp.new("\\A#{Regexp.escape(pattern)}\\z")
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Easyop
+  module Events
+    module Bus
+      # Wraps any user-supplied bus adapter.
+      #
+      # The adapter must respond to:
+      #   #publish(event)
+      #   #subscribe(pattern, &block)
+      #
+      # Optionally:
+      #   #unsubscribe(handle)
+      #
+      # @example Wrapping a RabbitMQ adapter
+      #   class MyRabbitBus
+      #     def publish(event) = rabbit.publish(event.to_h, routing_key: event.name)
+      #     def subscribe(pattern, &block) = rabbit.subscribe(pattern) { |msg| block.call(reconstruct(msg)) }
+      #   end
+      #
+      #   Easyop::Events::Registry.bus = MyRabbitBus.new
+      #
+      # @example Passing via Custom wrapper explicitly
+      #   Easyop::Events::Registry.bus = Easyop::Events::Bus::Custom.new(MyRabbitBus.new)
+      class Custom < Base
+        # @param adapter [Object] must respond to #publish and #subscribe
+        # @raise [ArgumentError] if adapter does not meet the interface
+        def initialize(adapter)
+          unless adapter.respond_to?(:publish) && adapter.respond_to?(:subscribe)
+            raise ArgumentError,
+              "Custom bus adapter must respond to #publish(event) and " \
+              "#subscribe(pattern, &block). Got: #{adapter.inspect}"
+          end
+          @adapter = adapter
+        end
+
+        def publish(event)
+          @adapter.publish(event)
+        end
+
+        def subscribe(pattern, &block)
+          @adapter.subscribe(pattern, &block)
+        end
+
+        def unsubscribe(handle)
+          @adapter.unsubscribe(handle) if @adapter.respond_to?(:unsubscribe)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Easyop
+  module Events
+    module Bus
+      # In-process, synchronous bus. Default adapter — requires no external gems.
+      #
+      # Thread-safe: subscriptions are protected by a Mutex, and publish snapshots
+      # the subscriber list before calling handlers so the lock is not held
+      # during handler execution (prevents deadlocks).
+      #
+      # @example
+      #   bus = Easyop::Events::Bus::Memory.new
+      #   bus.subscribe("order.placed") { |e| puts e.name }
+      #   bus.publish(Easyop::Events::Event.new(name: "order.placed"))
+      class Memory < Base
+        def initialize
+          @subscribers = []
+          @mutex       = Mutex.new
+        end
+
+        # Deliver +event+ to all matching subscribers.
+        # Handlers are called outside the lock; failures in individual handlers
+        # are swallowed so other handlers still run.
+        #
+        # @param event [Easyop::Events::Event]
+        def publish(event)
+          subs = @mutex.synchronize { @subscribers.dup }
+          subs.each do |sub|
+            sub[:handler].call(event) if _pattern_matches?(sub[:pattern], event.name)
+          rescue StandardError
+            # Individual handler failures must not prevent other handlers from running.
+          end
+        end
+
+        # Register a handler block for events matching +pattern+.
+        #
+        # @param pattern [String, Regexp]  exact name, glob, or Regexp
+        # @return [Hash] subscription handle (pass to #unsubscribe to remove)
+        def subscribe(pattern, &block)
+          entry = { pattern: pattern, handler: block }
+          @mutex.synchronize { @subscribers << entry }
+          entry
+        end
+
+        # Remove a previously registered subscription.
+        # @param handle [Hash] the value returned by #subscribe
+        def unsubscribe(handle)
+          @mutex.synchronize { @subscribers.delete(handle) }
+        end
+
+        # Remove all subscriptions. Useful in tests.
+        def clear!
+          @mutex.synchronize { @subscribers.clear }
+        end
+
+        # @return [Integer] number of active subscriptions
+        def subscriber_count
+          @mutex.synchronize { @subscribers.size }
+        end
+      end
+    end
+  end
+end

data/lib/easyop/events/bus.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Easyop
+  module Events
+    # Namespace for bus adapters.
+    # All adapters inherit from Easyop::Events::Bus::Base.
+    module Bus
+      # Abstract base for bus adapters.
+      #
+      # Subclasses must implement:
+      #   #publish(event)          — deliver event to matching subscribers
+      #   #subscribe(pattern, &block) — register a handler block
+      #
+      # Optionally override:
+      #   #unsubscribe(handle)     — remove a subscription (handle is return value of #subscribe)
+      class Base
+        # @param event [Easyop::Events::Event]
+        def publish(event)
+          raise NotImplementedError, "#{self.class}#publish must be implemented"
+        end
+
+        # @param pattern [String, Regexp]  event name, glob ("order.*"), or Regexp
+        # @yield [event] called when a matching event is published
+        # @return [Object] subscription handle (adapter-specific)
+        def subscribe(pattern, &block)
+          raise NotImplementedError, "#{self.class}#subscribe must be implemented"
+        end
+
+        # Remove a subscription created by #subscribe.
+        # @param handle [Object] the value returned by #subscribe
+        def unsubscribe(handle)
+          # default no-op — adapters may override
+        end
+
+        private
+
+        # Returns true when +pattern+ matches +event_name+.
+        # Supports exact strings, glob patterns ("order.*", "order.**"), and Regexp.
+        #
+        # Glob rules:
+        #   "*"  — matches any segment that doesn't cross a dot
+        #   "**" — matches any string including dots (greedy)
+        #
+        # @param pattern    [String, Regexp]
+        # @param event_name [String]
+        def _pattern_matches?(pattern, event_name)
+          case pattern
+          when Regexp
+            pattern.match?(event_name)
+          when String
+            pattern.include?("*") ? _glob_to_regex(pattern).match?(event_name) : pattern == event_name
+          end
+        end
+
+        # @param glob [String]  e.g. "order.*" or "warehouse.**"
+        # @return [Regexp]
+        def _glob_to_regex(glob)
+          escaped = Regexp.escape(glob)
+                          .gsub("\\*\\*", ".+")
+                          .gsub("\\*",    "[^.]+")
+          Regexp.new("\\A#{escaped}\\z")
+        end
+      end
+    end
+  end
+end

data/lib/easyop/events/event.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Easyop
+  module Events
+    # An immutable domain event value object.
+    #
+    # @example
+    #   event = Easyop::Events::Event.new(
+    #     name:    "order.placed",
+    #     payload: { order_id: 42, total: 9900 },
+    #     source:  "PlaceOrder"
+    #   )
+    #   event.name     # => "order.placed"
+    #   event.payload  # => { order_id: 42, total: 9900 }
+    #   event.frozen?  # => true
+    class Event
+      attr_reader :name, :payload, :metadata, :timestamp, :source
+
+      # @param name      [String]  event name, e.g. "order.placed"
+      # @param payload   [Hash]    domain data extracted from ctx
+      # @param metadata  [Hash]    extra envelope data (correlation_id, etc.)
+      # @param timestamp [Time]    defaults to Time.now
+      # @param source    [String]  class name of the emitting operation
+      def initialize(name:, payload: {}, metadata: {}, timestamp: nil, source: nil)
+        @name      = name.to_s.freeze
+        @payload   = payload.freeze
+        @metadata  = metadata.freeze
+        @timestamp = (timestamp || Time.now).freeze
+        @source    = source&.freeze
+        freeze
+      end
+
+      # @return [Hash] serializable hash representation
+      def to_h
+        { name: @name, payload: @payload, metadata: @metadata,
+          timestamp: @timestamp, source: @source }
+      end
+
+      def inspect
+        "#<Easyop::Events::Event name=#{@name.inspect} source=#{@source.inspect}>"
+      end
+    end
+  end
+end

data/lib/easyop/events/registry.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Easyop
+  module Events
+    # Thread-safe global registry for the event bus and handler subscriptions.
+    #
+    # The Registry is the coordination point between the Events plugin (producer)
+    # and the EventHandlers plugin (subscriber). Neither plugin references the other
+    # directly — they communicate only through the bus managed here.
+    #
+    # Configure the bus once at boot (e.g. in a Rails initializer):
+    #
+    #   Easyop::Events::Registry.bus = :memory           # default, in-process
+    #   Easyop::Events::Registry.bus = :active_support   # ActiveSupport::Notifications
+    #   Easyop::Events::Registry.bus = MyRabbitBus.new   # custom adapter
+    #
+    # Or via the global config:
+    #
+    #   Easyop.configure { |c| c.event_bus = :active_support }
+    #
+    # IMPORTANT: Configure the bus BEFORE handler classes are loaded (before
+    # autoloading runs in Rails). Subscriptions are registered at class load time
+    # and are bound to whatever bus is active at that moment.
+    class Registry
+      @mutex = Mutex.new
+
+      class << self
+        # Set the global bus adapter.
+        #
+        # @param bus_or_symbol [:memory, :active_support, Bus::Base, Object]
+        def bus=(bus_or_symbol)
+          @mutex.synchronize { @bus = _resolve_bus(bus_or_symbol) }
+        end
+
+        # Returns the active bus adapter. Defaults to a Memory bus.
+        #
+        # Falls back to Easyop.config.event_bus if set, then :memory.
+        #
+        # @return [Bus::Base]
+        def bus
+          @mutex.synchronize do
+            @bus ||= _resolve_bus(
+              defined?(Easyop.config) && Easyop.config.respond_to?(:event_bus) && Easyop.config.event_bus ||
+              :memory
+            )
+          end
+        end
+
+        # Register a handler operation as a subscriber for +pattern+.
+        #
+        # Called automatically by the EventHandlers plugin when `on` is declared.
+        #
+        # @param pattern       [String, Regexp]  event name or glob
+        # @param handler_class [Class]           operation class to invoke
+        # @param async         [Boolean]         use call_async (requires Async plugin)
+        # @param options       [Hash]            e.g. queue: "low"
+        def register_handler(pattern:, handler_class:, async: false, **options)
+          entry = { pattern: pattern, handler_class: handler_class,
+                    async: async, options: options }
+
+          @mutex.synchronize { _subscriptions << entry }
+
+          bus.subscribe(pattern) { |event| _dispatch(event, entry) }
+        end
+
+        # Returns a copy of all registered handler entries (for introspection).
+        #
+        # @return [Array<Hash>]
+        def subscriptions
+          @mutex.synchronize { _subscriptions.dup }
+        end
+
+        # Reset the registry: drop all subscriptions and replace the bus with a
+        # fresh Memory instance. Intended for use in tests (called in before/after hooks).
+        def reset!
+          @mutex.synchronize do
+            @bus           = nil
+            @subscriptions = nil
+          end
+        end
+
+        private
+
+        def _subscriptions
+          @subscriptions ||= []
+        end
+
+        # @api private — exposed for specs
+        def _dispatch(event, entry)
+          handler_class = entry[:handler_class]
+
+          if entry[:async] && handler_class.respond_to?(:call_async)
+            # Serialize Event to a plain hash for ActiveJob compatibility.
+            attrs = event.payload.merge(event_data: event.to_h)
+            queue = entry[:options][:queue]
+            handler_class.call_async(attrs, **(queue ? { queue: queue } : {}))
+          else
+            # Sync: pass Event object directly — ctx.event is the live Event instance.
+            handler_class.call(event: event, **event.payload)
+          end
+        rescue StandardError
+          # Handler failures must not propagate back to the publisher.
+        end
+
+        def _resolve_bus(bus_or_symbol)
+          case bus_or_symbol
+          when :memory
+            Bus::Memory.new
+          when :active_support
+            Bus::ActiveSupportNotifications.new
+          when Bus::Base
+            bus_or_symbol
+          when nil
+            Bus::Memory.new
+          else
+            if bus_or_symbol.respond_to?(:publish) && bus_or_symbol.respond_to?(:subscribe)
+              Bus::Custom.new(bus_or_symbol)
+            else
+              raise ArgumentError,
+                "Unknown bus: #{bus_or_symbol.inspect}. " \
+                "Use :memory, :active_support, or a bus adapter instance."
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/easyop/plugins/event_handlers.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Easyop
+  module Plugins
+    # Subscribes an operation class to handle domain events.
+    #
+    # The handler operation receives the event payload merged into ctx, plus
+    # ctx.event (the Easyop::Events::Event object itself for sync dispatch).
+    #
+    # Basic usage:
+    #
+    #   class SendOrderConfirmation < 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 Easyop::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
+    #       # For async dispatch ctx.event_data is a Hash (serialized for ActiveJob).
+    #       # Reconstruct if needed: Easyop::Events::Event.new(**ctx.event_data)
+    #       SearchIndex.reindex(ctx.order_id)
+    #     end
+    #   end
+    #
+    # Wildcard patterns:
+    #   "order.*"     — matches order.placed, order.shipped (not order.payment.failed)
+    #   "warehouse.**" — matches warehouse.stock.updated, warehouse.zone.moved, etc.
+    module EventHandlers
+      def self.install(base, **_options)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Subscribe this operation to events matching +pattern+.
+        #
+        # Registration happens at class-load time and is bound to the bus that is
+        # active when the class is evaluated. Configure the bus before loading
+        # handler classes (e.g. in a Rails initializer that runs before autoloading).
+        #
+        # @param pattern [String, Regexp]  event name or glob
+        # @param async   [Boolean]         enqueue via call_async (requires Async plugin)
+        # @param options [Hash]            e.g. queue: "low" (overrides Async default)
+        def on(pattern, async: false, **options)
+          _event_handler_registrations << { pattern: pattern, async: async, options: options }
+
+          Easyop::Events::Registry.register_handler(
+            pattern:       pattern,
+            handler_class: self,
+            async:         async,
+            **options
+          )
+        end
+
+        # @api private — list of registrations declared on this class
+        def _event_handler_registrations
+          @_event_handler_registrations ||= []
+        end
+      end
+    end
+  end
+end

data/lib/easyop/plugins/events.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Easyop
+  module Plugins
+    # Emits domain events after an operation completes.
+    #
+    # Install on a base operation class to inherit into all subclasses:
+    #
+    #   class ApplicationOperation
+    #     include Easyop::Operation
+    #     plugin Easyop::Plugins::Events
+    #   end
+    #
+    # Then declare events on individual operations:
+    #
+    #   class PlaceOrder < ApplicationOperation
+    #     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
+    #
+    # Plugin options:
+    #   bus:      [Bus::Base, nil]  per-class bus override (default: global registry bus)
+    #   metadata: [Hash, Proc, nil] extra metadata merged into every event from this class
+    #
+    # `emits` DSL options:
+    #   on:      [:success (default), :failure, :always]
+    #   payload: [Proc, Array, nil]  Proc receives ctx; Array slices ctx keys; nil = full ctx.to_h
+    #   guard:   [Proc, nil]         extra condition — event only fires if truthy
+    module Events
+      def self.install(base, bus: nil, metadata: nil, **_options)
+        base.extend(ClassMethods)
+        base.prepend(RunWrapper)
+        base.instance_variable_set(:@_events_bus,      bus)
+        base.instance_variable_set(:@_events_metadata, metadata)
+      end
+
+      module ClassMethods
+        # Declare an event this operation emits after execution.
+        #
+        # @example
+        #   emits "order.placed", on: :success, payload: [:order_id]
+        #   emits "order.failed", on: :failure, payload: ->(ctx) { { error: ctx.error } }
+        #
+        # @param name   [String]
+        # @param on     [Symbol]        :success (default), :failure, or :always
+        # @param payload [Proc, Array, nil]
+        # @param guard  [Proc, nil]     optional condition — fires only when truthy
+        def emits(name, on: :success, payload: nil, guard: nil)
+          _emitted_events << { name: name.to_s, on: on, payload: payload, guard: guard }
+        end
+
+        # @api private — inheritable list of emits declarations
+        def _emitted_events
+          @_emitted_events ||= _inherited_emitted_events
+        end
+
+        # @api private — bus for this class (falls back to superclass, then global registry)
+        def _events_bus
+          if instance_variable_defined?(:@_events_bus)
+            @_events_bus
+          elsif superclass.respond_to?(:_events_bus)
+            superclass._events_bus
+          end
+        end
+
+        # @api private — metadata for this class (falls back to superclass)
+        def _events_metadata
+          if instance_variable_defined?(:@_events_metadata)
+            @_events_metadata
+          elsif superclass.respond_to?(:_events_metadata)
+            superclass._events_metadata
+          end
+        end
+
+        private
+
+        def _inherited_emitted_events
+          superclass.respond_to?(:_emitted_events) ? superclass._emitted_events.dup : []
+        end
+      end
+
+      module RunWrapper
+        # Wraps _easyop_run to publish declared events in an ensure block.
+        # Events fire AFTER the operation completes — success, failure, or exception.
+        def _easyop_run(ctx, raise_on_failure:)
+          super
+        ensure
+          _events_publish_all(ctx)
+        end
+
+        private
+
+        def _events_publish_all(ctx)
+          declarations = self.class._emitted_events
+          return if declarations.empty?
+
+          bus = self.class._events_bus || Easyop::Events::Registry.bus
+
+          declarations.each do |decl|
+            next unless _events_should_fire?(decl, ctx)
+
+            event = _events_build_event(decl, ctx)
+            bus.publish(event)
+          rescue StandardError
+            # Individual publish failures must never crash the operation.
+            # Log if Rails is available.
+            _events_log_warning($ERROR_INFO)
+          end
+        end
+
+        def _events_should_fire?(decl, ctx)
+          case decl[:on]
+          when :success then return false unless ctx.success?
+          when :failure then return false unless ctx.failure?
+          when :always  then nil # always fire
+          end
+
+          guard = decl[:guard]
+          guard ? guard.call(ctx) : true
+        end
+
+        def _events_build_event(decl, ctx)
+          Easyop::Events::Event.new(
+            name:      decl[:name],
+            payload:   _events_extract_payload(decl[:payload], ctx),
+            metadata:  _events_build_metadata(ctx),
+            source:    self.class.name
+          )
+        end
+
+        def _events_extract_payload(payload_spec, ctx)
+          case payload_spec
+          when Proc  then payload_spec.call(ctx)
+          when Array then ctx.slice(*payload_spec)
+          when nil   then ctx.to_h
+          else payload_spec
+          end
+        end
+
+        def _events_build_metadata(ctx)
+          meta = self.class._events_metadata
+          case meta
+          when Proc then meta.call(ctx)
+          when Hash then meta.dup
+          else {}
+          end
+        end
+
+        def _events_log_warning(err)
+          return unless defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+
+          Rails.logger.warn "[EasyOp::Events] Failed to publish event: #{err.message}"
+        end
+      end
+    end
+  end
+end

data/lib/easyop/version.rb

@@ -1,3 +1,3 @@
 module Easyop
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/easyop.rb

@@ -18,6 +18,17 @@ require_relative "easyop/flow"
 # require "easyop/plugins/recording"
 # require "easyop/plugins/async"
 
+# Domain event plugins — require together or individually:
+# require "easyop/events/event"
+# require "easyop/events/bus"
+# require "easyop/events/bus/memory"
+# require "easyop/events/bus/active_support_notifications"
+# require "easyop/events/bus/custom"
+# require "easyop/events/bus/adapter"   # inherit this to build a custom bus
+# require "easyop/events/registry"
+# require "easyop/plugins/events"
+# require "easyop/plugins/event_handlers"
+
 module Easyop
   # Convenience: inherit from this instead of including Easyop::Operation
   # when you want a common base class for all your operations.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: easyop
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Pawel Niemczyk
@@ -53,12 +53,21 @@ files:
 - lib/easyop.rb
 - lib/easyop/configuration.rb
 - lib/easyop/ctx.rb
+- lib/easyop/events/bus.rb
+- lib/easyop/events/bus/active_support_notifications.rb
+- lib/easyop/events/bus/adapter.rb
+- lib/easyop/events/bus/custom.rb
+- lib/easyop/events/bus/memory.rb
+- lib/easyop/events/event.rb
+- lib/easyop/events/registry.rb
 - lib/easyop/flow.rb
 - lib/easyop/flow_builder.rb
 - lib/easyop/hooks.rb
 - lib/easyop/operation.rb
 - lib/easyop/plugins/async.rb
 - lib/easyop/plugins/base.rb
+- lib/easyop/plugins/event_handlers.rb
+- lib/easyop/plugins/events.rb
 - lib/easyop/plugins/instrumentation.rb
 - lib/easyop/plugins/recording.rb
 - lib/easyop/plugins/transactional.rb