bcdd-result 0.12.0 → 1.0.0

data/README.md

@@ -1,9 +1,11 @@
 <p align="center">
   <h1 align="center" id="-bcddresult">🔀 BCDD::Result</h1>
-  <p align="center"><i>Empower Ruby apps with pragmatic use of Result pattern (monad), Railway Oriented Programming, and B/CDD.</i></p>
+  <p align="center"><i>Unleash a pragmatic and observable use of Result Pattern and Railway-Oriented Programming in Ruby.</i></p>
   <p align="center">
-    <img src="https://img.shields.io/badge/ruby->%3D%202.7.0-ruby.svg?colorA=99004d&colorB=cc0066" alt="Ruby">
+    <img src="https://img.shields.io/badge/Ruby%20%3E%3D%202.7%2C%20%3C%3D%20Head-ruby.svg?colorA=444&colorB=333" alt="Ruby">
     <a href="https://rubygems.org/gems/bcdd-result"><img src="https://badge.fury.io/rb/bcdd-result.svg" alt="bcdd-result gem version" height="18"></a>
+    <a href="https://codeclimate.com/github/B-CDD/result/maintainability"><img src="https://api.codeclimate.com/v1/badges/aa8360f8f012d7dedd62/maintainability" /></a>
+    <a href="https://codeclimate.com/github/B-CDD/result/test_coverage"><img src="https://api.codeclimate.com/v1/badges/aa8360f8f012d7dedd62/test_coverage" /></a>
   </p>
 </p>
 
@@ -17,12 +19,13 @@ Furthermore, this abstraction exposes several features that will be useful to ma
 
 Use it to enable the [Railway Oriented Programming](https://fsharpforfunandprofit.com/rop/) pattern (superpower) in your code.
 
-- [Ruby Version](#ruby-version)
+- [Supported Ruby](#supported-ruby)
 - [Installation](#installation)
 - [Usage](#usage)
     - [`BCDD::Result` *versus* `Result`](#bcddresult-versus-result)
 - [Reference](#reference)
-  - [Result Attributes](#result-attributes)
+  - [Basic methods](#basic-methods)
+    - [Checking types with `result.is?` or `method missing`](#checking-types-with-resultis-or-method-missing)
     - [Checking types with `result.success?` or `result.failure?`](#checking-types-with-resultsuccess-or-resultfailure)
   - [Result Hooks](#result-hooks)
     - [`result.on`](#resulton)
@@ -35,9 +38,6 @@ Use it to enable the [Railway Oriented Programming](https://fsharpforfunandprofi
     - [`result.value_or`](#resultvalue_or)
   - [Result Data](#result-data)
     - [`result.data`](#resultdata)
-  - [Pattern Matching](#pattern-matching)
-    - [`Array`/`Find` patterns](#arrayfind-patterns)
-    - [`Hash` patterns](#hash-patterns)
   - [Railway Oriented Programming](#railway-oriented-programming)
     - [`result.and_then`](#resultand_then)
     - [`BCDD::Result.mixin`](#bcddresultmixin)
@@ -61,22 +61,31 @@ Use it to enable the [Railway Oriented Programming](https://fsharpforfunandprofi
       - [Failure()](#failure)
       - [Pattern Matching Support](#pattern-matching-support)
     - [`BCDD::Result::Expectations.mixin` add-ons](#bcddresultexpectationsmixin-add-ons)
-  - [`BCDD::Result::Context`](#bcddresultcontext)
+  - [`BCDD::Context`](#bcddcontext)
     - [Defining successes and failures](#defining-successes-and-failures)
     - [Constant aliases](#constant-aliases)
-    - [`BCDD::Result::Context.mixin`](#bcddresultcontextmixin)
+    - [`BCDD::Context.mixin`](#bcddcontextmixin)
       - [Class example (Instance Methods)](#class-example-instance-methods-1)
       - [`and_expose`](#and_expose)
       - [Module example (Singleton Methods)](#module-example-singleton-methods-1)
-    - [`BCDD::Result::Context::Expectations`](#bcddresultcontextexpectations)
+    - [`BCDD::Context::Expectations`](#bcddcontextexpectations)
     - [Mixin add-ons](#mixin-add-ons)
-  - [`BCDD::Result.transitions`](#bcddresulttransitions)
-    - [Configuration](#configuration)
-  - [`BCDD::Result.configuration`](#bcddresultconfiguration)
-    - [`config.addon.enable!(:given, :continue)`](#configaddonenablegiven-continue)
-    - [`config.constant_alias.enable!('Result', 'BCDD::Context')`](#configconstant_aliasenableresult-bcddcontext)
-    - [`config.pattern_matching.disable!(:nil_as_valid_value_checking)`](#configpattern_matchingdisablenil_as_valid_value_checking)
-    - [`config.feature.disable!(:expectations)`](#configfeaturedisableexpectations)
+- [Pattern Matching](#pattern-matching)
+  - [`BCDD::Result`](#bcddresult)
+    - [`Array`/`Find` patterns](#arrayfind-patterns)
+    - [`Hash` patterns](#hash-patterns)
+  - [`BCDD::Context`](#bcddcontext-1)
+    - [`Array`/`Find` patterns](#arrayfind-patterns-1)
+    - [`Hash` patterns](#hash-patterns-1)
+  - [How to pattern match without the concept of success and failure](#how-to-pattern-match-without-the-concept-of-success-and-failure)
+- [`BCDD::Result.event_logs`](#bcddresultevent_logs)
+  - [`metadata: {ids:}`](#metadata-ids)
+  - [Configuration](#configuration)
+    - [Turning on/off](#turning-onoff)
+    - [Setting a `trace_id` fetcher](#setting-a-trace_id-fetcher)
+    - [Setting a `listener`](#setting-a-listener)
+    - [Setting multiple `listeners`](#setting-multiple-listeners)
+- [`BCDD::Result.configuration`](#bcddresultconfiguration)
   - [`BCDD::Result.config`](#bcddresultconfig)
 - [`BCDD::Result#and_then!`](#bcddresultand_then)
     - [Dependency Injection](#dependency-injection-1)
@@ -90,9 +99,13 @@ Use it to enable the [Railway Oriented Programming](https://fsharpforfunandprofi
 - [License](#license)
 - [Code of Conduct](#code-of-conduct)
 
-## Ruby Version
+## Supported Ruby
+
+This library is tested against:
 
-`>= 2.7.0`
+Version | 2.7 | 3.0 | 3.1 | 3.2 | 3.3 | Head
+---- | --- | --- | --- | --- | --- | ---
+100% Coverage | ✅  | ✅  | ✅  | ✅  | ✅  | ✅
 
 ## Installation
 
@@ -164,7 +177,7 @@ There are other aliases and configurations available. Check the [BCDD::Result.co
 
 ## Reference
 
-### Result Attributes
+### Basic methods
 
 Both `BCDD::Result::Success` and `BCDD::Result::Failure` are composed of the same methods. Look at the basic ones:
 
@@ -176,20 +189,22 @@ Both `BCDD::Result::Success` and `BCDD::Result::Failure` are composed of the sam
 ################
 result = BCDD::Result::Success(:ok, my: 'value')
 
-result.success? # true
-result.failure? # false
-result.type     # :ok
-result.value    # {:my => "value"}
+result.success?   # true
+result.failure?   # false
+result.type?(:ok) # true
+result.type       # :ok
+result.value      # {:my => "value"}
 
 ###################
 # Without a value #
 ###################
 result = BCDD::Result::Success(:yes)
 
-result.success? # true
-result.failure? # false
-result.type     # :yes
-result.value    # nil
+result.success?    # true
+result.failure?    # false
+result.type?(:yes) # true
+result.type        # :yes
+result.value       # nil
 ```
 
 **BCDD::Result::Failure**
@@ -200,26 +215,46 @@ result.value    # nil
 ################
 result = BCDD::Result::Failure(:err, 'my_value')
 
-result.success? # false
-result.failure? # true
-result.type     # :err
-result.value    # "my_value"
+result.success?    # false
+result.failure?    # true
+result.type?(:err) # true
+result.type        # :err
+result.value       # "my_value"
 
 ###################
 # Without a value #
 ###################
 result = BCDD::Result::Failure(:no)
 
-result.success? # false
-result.failure? # true
-result.type     # :no
-result.value    # nil
+result.success?   # false
+result.failure?   # true
+result.type?(:no) # true
+result.type       # :no
+result.value      # nil
 ```
 
 In both cases, the `type` must be a symbol, and the `value` can be any kind of object.
 
 <p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
 
+#### Checking types with `result.is?` or `method missing`
+
+Beyond the `type?` method, you can also use the `is?` method to check the result type. If you want to check the type directly, you can write the type using a method that ends with a question mark.
+
+```ruby
+result = BCDD::Result::Success(:ok)
+
+result.is?(:ok) # true
+result.ok?      # true
+
+result = BCDD::Result::Failure(:err)
+
+result.is?(:err) # true
+result.err?      # true
+```
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
 #### Checking types with `result.success?` or `result.failure?`
 
 `BCDD::Result#success?` and `BCDD::Result#failure?` are methods that allow you to check if the result is a success or a failure.
@@ -530,67 +565,6 @@ print_to_hash(**success_data) # [:success, :ok, 1]
 
 <p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
 
-### Pattern Matching
-
-The `BCDD::Result` also provides support to pattern matching.
-
-In the further examples, I will use the `Divide` lambda to exemplify its usage.
-
-```ruby
-Divide = lambda do |arg1, arg2|
-  arg1.is_a?(::Numeric) or return BCDD::Result::Failure(:invalid_arg, 'arg1 must be numeric')
-  arg2.is_a?(::Numeric) or return BCDD::Result::Failure(:invalid_arg, 'arg2 must be numeric')
-
-  return BCDD::Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
-
-  BCDD::Result::Success(:division_completed, arg1 / arg2)
-end
-```
-
-#### `Array`/`Find` patterns
-
-```ruby
-case Divide.call(4, 2)
-in BCDD::Result::Failure[:invalid_arg, msg] then puts msg
-in BCDD::Result::Failure[:division_by_zero, msg] then puts msg
-in BCDD::Result::Success[:division_completed, value] then puts value
-end
-
-# The code above will print: 2
-
-case Divide.call(4, 0)
-in BCDD::Result::Failure[:invalid_arg, msg] then puts msg
-in BCDD::Result::Failure[:division_by_zero, msg] then puts msg
-in BCDD::Result::Success[:division_completed, value] then puts value
-end
-
-# The code above will print: arg2 must not be zero
-```
-
-<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
-
-#### `Hash` patterns
-
-```ruby
-case Divide.call(10, 2)
-in { failure: { invalid_arg: msg } } then puts msg
-in { failure: { division_by_zero: msg } } then puts msg
-in { success: { division_completed: value } } then puts value
-end
-
-# The code above will print: 5
-
-case Divide.call('10', 2)
-in { failure: { invalid_arg: msg } } then puts msg
-in { failure: { division_by_zero: msg } } then puts msg
-in { success: { division_completed: value } } then puts value
-end
-
-# The code above will print: arg1 must be numeric
-```
-
-<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
-
 ### Railway Oriented Programming
 
 ["Railway Oriented Programming (ROP)"](https://fsharpforfunandprofit.com/rop/)  is a programming technique that involves linking blocks together to form a sequence of operations, also known as a pipeline.
@@ -1418,7 +1392,7 @@ result = Divide.new.call(4, 2)
 
 # The example below shows an error because the :ok type is not allowed.
 # But look at the allowed types have only one type (:division_completed).
-# This is because the :continued type is ignored by the expectations.
+# This is because the :_continue_ type is ignored by the expectations.
 #
 result.success?(:ok)
 # type :ok is not allowed. Allowed types: :division_completed (BCDD::Result::Contract::Error::UnexpectedType)
@@ -1426,45 +1400,45 @@ result.success?(:ok)
 
 <p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
 
-### `BCDD::Result::Context`
+### `BCDD::Context`
 
-The `BCDD::Result::Context` is a `BCDD::Result`, meaning it has all the features of the `BCDD::Result`. The main difference is that it only accepts keyword arguments as a value, which applies to the `and_then`: The called methods must receive keyword arguments, and the dependency injection will be performed through keyword arguments.
+The `BCDD::Context` is a `BCDD::Result`, meaning it has all the features of the `BCDD::Result`. The main difference is that it only accepts keyword arguments as a value, which applies to the `and_then`: The called methods must receive keyword arguments, and the dependency injection will be performed through keyword arguments.
 
-As the input/output are hashes, the results of each `and_then` call will automatically accumulate. This is useful in operations chaining, as the result of the previous operations will be automatically available for the next one. Because of this behavior, the `BCDD::Result::Context` has the `#and_expose` method to expose only the desired keys from the accumulated result.
+As the input/output are hashes, the results of each `and_then` call will automatically accumulate. This is useful in operations chaining, as the result of the previous operations will be automatically available for the next one. Because of this behavior, the `BCDD::Context` has the `#and_expose` method to expose only the desired keys from the accumulated result.
 
 #### Defining successes and failures
 
-As the `BCDD::Result`, you can declare success and failures directly from `BCDD::Result::Context`.
+As the `BCDD::Result`, you can declare success and failures directly from `BCDD::Context`.
 
 ```ruby
-BCDD::Result::Context::Success(:ok, a: 1, b: 2)
-#<BCDD::Result::Context::Success type=:ok value={:a=>1, :b=>2}>
+BCDD::Context::Success(:ok, a: 1, b: 2)
+#<BCDD::Context::Success type=:ok value={:a=>1, :b=>2}>
 
-BCDD::Result::Context::Failure(:err, message: 'something went wrong')
-#<BCDD::Result::Context::Failure type=:err value={:message=>"something went wrong"}>
+BCDD::Context::Failure(:err, message: 'something went wrong')
+#<BCDD::Context::Failure type=:err value={:message=>"something went wrong"}>
 ```
 
-But different from `BCDD::Result` that accepts any value, the `BCDD::Result::Context` only takes keyword arguments.
+But different from `BCDD::Result` that accepts any value, the `BCDD::Context` only takes keyword arguments.
 
 ```ruby
-BCDD::Result::Context::Success(:ok, [1, 2])
+BCDD::Context::Success(:ok, [1, 2])
 # wrong number of arguments (given 2, expected 1) (ArgumentError)
 
-BCDD::Result::Context::Failure(:err, { message: 'something went wrong' })
+BCDD::Context::Failure(:err, { message: 'something went wrong' })
 # wrong number of arguments (given 2, expected 1) (ArgumentError)
 
 #
 # Use ** to convert a hash to keyword arguments
 #
-BCDD::Result::Context::Success(:ok, **{ message: 'hashes can be converted to keyword arguments' })
-#<BCDD::Result::Context::Success type=:ok value={:message=>"hashes can be converted to keyword arguments"}>
+BCDD::Context::Success(:ok, **{ message: 'hashes can be converted to keyword arguments' })
+#<BCDD::Context::Success type=:ok value={:message=>"hashes can be converted to keyword arguments"}>
 ```
 
 <p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
 
 #### Constant aliases
 
-You can configure `Context` or `BCDD::Context` as an alias for `BCDD::Result::Context`. This is helpful to define a standard way to avoid the full constant name/path in your code.
+You can configure `Context` or `BCDD::Context` as an alias for `BCDD::Context`. This is helpful to define a standard way to avoid the full constant name/path in your code.
 
 ```ruby
 BCDD::Result.configuration do |config|
@@ -1478,9 +1452,9 @@ end
 
 <p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
 
-#### `BCDD::Result::Context.mixin`
+#### `BCDD::Context.mixin`
 
-As in the `BCDD::Result`, you can use the `BCDD::Result::Context.mixin` to add the `Success()` and `Failure()` methods to your classes/modules.
+As in the `BCDD::Result`, you can use the `BCDD::Context.mixin` to add the `Success()` and `Failure()` methods to your classes/modules.
 
 Let's see this feature and the data accumulation in action:
 
@@ -1490,7 +1464,7 @@ Let's see this feature and the data accumulation in action:
 require 'logger'
 
 class Divide
-  include BCDD::Result::Context.mixin
+  include BCDD::Context.mixin
 
   def call(arg1, arg2, logger: ::Logger.new(STDOUT))
     validate_numbers(arg1, arg2)
@@ -1527,29 +1501,29 @@ end
 
 Divide.new.call(10, 5)
 # I, [2023-10-27T01:51:46.905004 #76915]  INFO -- : The division result is 2
-#<BCDD::Result::Context::Success type=:ok value={:number=>2}>
+#<BCDD::Context::Success type=:ok value={:number=>2}>
 
 Divide.new.call('10', 5)
-#<BCDD::Result::Context::Failure type=:err value={:message=>"arg1 must be numeric"}>
+#<BCDD::Context::Failure type=:err value={:message=>"arg1 must be numeric"}>
 
 Divide.new.call(10, '5')
-#<BCDD::Result::Context::Failure type=:err value={:message=>"arg2 must be numeric"}>
+#<BCDD::Context::Failure type=:err value={:message=>"arg2 must be numeric"}>
 
 Divide.new.call(10, 0)
-#<BCDD::Result::Context::Failure type=:err value={:message=>"arg2 must not be zero"}>
+#<BCDD::Context::Failure type=:err value={:message=>"arg2 must not be zero"}>
 ```
 
 <p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
 
 ##### `and_expose`
 
-This allows you to expose only the desired keys from the accumulated result. It can be used with any `BCDD::Result::Context` object.
+This allows you to expose only the desired keys from the accumulated result. It can be used with any `BCDD::Context` object.
 
 Let's add it to the previous example:
 
 ```ruby
 class Divide
-  include BCDD::Result::Context.mixin
+  include BCDD::Context.mixin
 
   def call(arg1, arg2)
     validate_numbers(arg1, arg2)
@@ -1579,7 +1553,7 @@ class Divide
 end
 
 Divide.new.call(10, 5)
-#<BCDD::Result::Context::Success type=:division_completed value={:number=>2}>
+#<BCDD::Context::Success type=:division_completed value={:number=>2}>
 ```
 
 As you can see, even with `divide` success exposing the division number with all the accumulated data (`**input`), the `#and_expose` could generate a new success with a new type and only with the desired keys.
@@ -1588,7 +1562,7 @@ Remove the `#and_expose` call to see the difference. This will be the outcome:
 
 ```ruby
 Divide.new.call(10, 5)
-#<BCDD::Result::Context::Success type=:ok value={:number=>2, :number1=>10, :number2=>5}>
+#<BCDD::Context::Success type=:ok value={:number=>2, :number1=>10, :number2=>5}>
 ```
 
 > PS: The `#and_expose` produces a terminal success by default. This means the next step will not be executed even if you call `#and_then` after `#and_expose`. To change this behavior, you can pass `terminal: false` to `#and_expose`.
@@ -1597,11 +1571,11 @@ Divide.new.call(10, 5)
 
 ##### Module example (Singleton Methods)
 
-`BCDD::Result::Context.mixin` can also produce singleton methods. Below is an example using a module (but it could be a class, too).
+`BCDD::Context.mixin` can also produce singleton methods. Below is an example using a module (but it could be a class, too).
 
 ```ruby
 module Divide
-  extend self, BCDD::Result::Context.mixin
+  extend self, BCDD::Context.mixin
 
   def call(arg1, arg2)
     validate_numbers(arg1, arg2)
@@ -1631,29 +1605,29 @@ module Divide
 end
 
 Divide.call(10, 5)
-#<BCDD::Result::Context::Success type=:division_completed value={:number=>2}>
+#<BCDD::Context::Success type=:division_completed value={:number=>2}>
 
 Divide.call('10', 5)
-#<BCDD::Result::Context::Failure type=:err value={:message=>"arg1 must be numeric"}>
+#<BCDD::Context::Failure type=:err value={:message=>"arg1 must be numeric"}>
 
 Divide.call(10, '5')
-#<BCDD::Result::Context::Failure type=:err value={:message=>"arg2 must be numeric"}>
+#<BCDD::Context::Failure type=:err value={:message=>"arg2 must be numeric"}>
 
 Divide.call(10, 0)
-#<BCDD::Result::Context::Failure type=:err value={:message=>"arg2 must not be zero"}>
+#<BCDD::Context::Failure type=:err value={:message=>"arg2 must not be zero"}>
 ```
 
 <p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
 
-#### `BCDD::Result::Context::Expectations`
+#### `BCDD::Context::Expectations`
 
-The `BCDD::Result::Context::Expectations` is a `BCDD::Result::Expectations` with the `BCDD::Result::Context` features.
+The `BCDD::Context::Expectations` is a `BCDD::Result::Expectations` with the `BCDD::Context` features.
 
 This is an example using the mixin mode, but the standalone mode is also supported.
 
 ```ruby
 class Divide
-  include BCDD::Result::Context::Expectations.mixin(
+  include BCDD::Context::Expectations.mixin(
     config: {
       pattern_matching: { nil_as_valid_value_checking: true }
     },
@@ -1677,16 +1651,16 @@ class Divide
 end
 
 Divide.new.call(10, 5)
-#<BCDD::Result::Context::Success type=:division_completed value={:number=>2}>
+#<BCDD::Context::Success type=:division_completed value={:number=>2}>
 ```
 
-As in the `BCDD::Result::Expectations.mixin`, the `BCDD::Result::Context::Expectations.mixin` will add a Result constant in the target class. It can generate success/failure results, which ensure the mixin expectations.
+As in the `BCDD::Result::Expectations.mixin`, the `BCDD::Context::Expectations.mixin` will add a Result constant in the target class. It can generate success/failure results, which ensure the mixin expectations.
 
 Let's see this using the previous example:
 
 ```ruby
 Divide::Result::Success(:division_completed, number: 2)
-#<BCDD::Result::Context::Success type=:division_completed value={:number=>2}>
+#<BCDD::Context::Success type=:division_completed value={:number=>2}>
 
 Divide::Result::Success(:division_completed, number: '2')
 # value {:number=>"2"} is not allowed for :division_completed type ({:number=>"2"}: Numeric === "2" does not return true) (BCDD::Result::Contract::Error::UnexpectedValue)
@@ -1696,7 +1670,7 @@ Divide::Result::Success(:division_completed, number: '2')
 
 #### Mixin add-ons
 
-The `BCDD::Result::Context.mixin` and `BCDD::Result::Context::Expectations.mixin` also accepts the `config:` argument. And it works the same way as the `BCDD::Result` mixins.
+The `BCDD::Context.mixin` and `BCDD::Context::Expectations.mixin` also accepts the `config:` argument. And it works the same way as the `BCDD::Result` mixins.
 
 **given**
 
@@ -1704,21 +1678,21 @@ This addon is enabled by default. It will create the `Given(*value)` method. Use
 
 You can turn it off by passing `given: false` to the `config:` argument or using the `BCDD::Result.configuration`.
 
-The `Given()` addon for a BCDD::Result::Context can be called with one or more arguments. The arguments will be converted to a hash (`to_h`) and merged to define the first value of the result chain.
+The `Given()` addon for a BCDD::Context can be called with one or more arguments. The arguments will be converted to a hash (`to_h`) and merged to define the first value of the result chain.
 
 **continue**
 
-The `BCDD::Result::Context.mixin(config: { addon: { continue: true } })` or `BCDD::Result::Context::Expectations.mixin(config: { addon: { continue: true } })` creates the `Continue(value)` method and change the `Success()` behavior to terminate the step chain.
+The `BCDD::Context.mixin(config: { addon: { continue: true } })` or `BCDD::Context::Expectations.mixin(config: { addon: { continue: true } })` creates the `Continue(value)` method and change the `Success()` behavior to terminate the step chain.
 
 So, if you want to advance to the next step, you must use `Continue(**value)` instead of `Success(type, **value)`. Otherwise, the step chain will be terminated.
 
-Let's use a mix of `BCDD::Result::Context` features to see in action with this add-on:
+Let's use a mix of `BCDD::Context` features to see in action with this add-on:
 
 ```ruby
 module Division
   require 'logger'
 
-  extend self, BCDD::Result::Context::Expectations.mixin(
+  extend self, BCDD::Context::Expectations.mixin(
     config: {
       addon:            { continue: true },
       pattern_matching: { nil_as_valid_value_checking: true }
@@ -1768,33 +1742,193 @@ end
 
 Division.call(14, 2)
 # I, [2023-10-27T02:01:05.812388 #77823]  INFO -- : The division result is 7
-#<BCDD::Result::Context::Success type=:division_completed value={:number=>7}>
+#<BCDD::Context::Success type=:division_completed value={:number=>7}>
 
 Division.call(0, 2)
-##<BCDD::Result::Context::Success type=:division_completed value={:number=>0}>
+##<BCDD::Context::Success type=:division_completed value={:number=>0}>
 
 Division.call('14', 2)
-#<BCDD::Result::Context::Failure type=:invalid_arg value={:message=>"arg1 must be numeric"}>
+#<BCDD::Context::Failure type=:invalid_arg value={:message=>"arg1 must be numeric"}>
 
 Division.call(14, '2')
-#<BCDD::Result::Context::Failure type=:invalid_arg value={:message=>"arg2 must be numeric"}>
+#<BCDD::Context::Failure type=:invalid_arg value={:message=>"arg2 must be numeric"}>
 
 Division.call(14, 0)
-#<BCDD::Result::Context::Failure type=:division_by_zero value={:message=>"arg2 must not be zero"}>
+#<BCDD::Context::Failure type=:division_by_zero value={:message=>"arg2 must not be zero"}>
+```
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+## Pattern Matching
+
+The `BCDD::Result` and `BCDD::Context` also provides support to pattern matching.
+
+### `BCDD::Result`
+
+In the further examples, I will use the `Divide` lambda to exemplify its usage.
+
+```ruby
+Divide = lambda do |arg1, arg2|
+  arg1.is_a?(::Numeric) or return BCDD::Result::Failure(:invalid_arg, 'arg1 must be numeric')
+  arg2.is_a?(::Numeric) or return BCDD::Result::Failure(:invalid_arg, 'arg2 must be numeric')
+
+  return BCDD::Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
+
+  BCDD::Result::Success(:division_completed, arg1 / arg2)
+end
+```
+
+#### `Array`/`Find` patterns
+
+```ruby
+case Divide.call(4, 2)
+in BCDD::Failure[:invalid_arg, msg] then puts msg
+in BCDD::Failure[:division_by_zero, msg] then puts msg
+in BCDD::Success[:division_completed, num] then puts num
+end
+
+# The code above will print: 2
+
+case Divide.call(4, 0)
+in BCDD::Failure[:invalid_arg, msg] then puts msg
+in BCDD::Failure[:division_by_zero, msg] then puts msg
+in BCDD::Success[:division_completed, num] then puts num
+end
+
+# The code above will print: arg2 must not be zero
+```
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+#### `Hash` patterns
+
+```ruby
+case Divide.call(10, 2)
+in BCDD::Failure(type: :invalid_arg, value: msg) then puts msg
+in BCDD::Failure(type: :division_by_zero, value: msg) then puts msg
+in BCDD::Success(type: :division_completed, value: num) then puts num
+end
+
+# The code above will print: 5
+
+case Divide.call('10', 2)
+in BCDD::Failure(type: :invalid_arg, value: msg) then puts msg
+in BCDD::Failure(type: :division_by_zero, value: msg) then puts msg
+in BCDD::Success(type: :division_completed, value: num) then puts num
+end
+
+# The code above will print: arg1 must be numeric
+```
+
+You can also use `BCDD::Result::Success` and `BCDD::Result::Failure` as patterns.
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+
+### `BCDD::Context`
+
+In the further examples, I will use the `Divide` lambda to exemplify its usage.
+
+```ruby
+Divide = lambda do |arg1, arg2|
+  arg1.is_a?(::Numeric) or return BCDD::Context::Failure(:invalid_arg, err: 'arg1 must be numeric')
+  arg2.is_a?(::Numeric) or return BCDD::Context::Failure(:invalid_arg, err: 'arg2 must be numeric')
+
+  return BCDD::Context::Failure(:division_by_zero, err: 'arg2 must not be zero') if arg2.zero?
+
+  BCDD::Context::Success(:division_completed, num: arg1 / arg2)
+end
+```
+
+#### `Array`/`Find` patterns
+
+```ruby
+case Divide.call(4, 2)
+in BCDD::Failure[:invalid_arg, {msg:}] then puts msg
+in BCDD::Failure[:division_by_zero, {msg:}] then puts msg
+in BCDD::Success[:division_completed, {num:}] then puts num
+end
+
+# The code above will print: 2
+
+case Divide.call(4, 0)
+in BCDD::Failure[:invalid_arg, {msg:}] then puts msg
+in BCDD::Failure[:division_by_zero, {msg:}] then puts msg
+in BCDD::Success[:division_completed, {num:}] then puts num
+end
+
+# The code above will print: arg2 must not be zero
+```
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+#### `Hash` patterns
+
+If you don't provide the keys :type and :value, the pattern will match the result value.
+
+```ruby
+case Divide.call(10, 2)
+in BCDD::Failure({msg:}) then puts msg
+in BCDD::Success({num:}) then puts num
+end
+```
+
+```ruby
+case Divide.call(10, 2)
+in BCDD::Failure(type: :invalid_arg, value: {msg:}) then puts msg
+in BCDD::Failure(type: :division_by_zero, value: {msg:}) then puts msg
+in BCDD::Success(type: :division_completed, value: {num:}) then puts num
+end
+
+# The code above will print: 5
+
+case Divide.call('10', 2)
+in BCDD::Failure(type: :invalid_arg, value: {msg:}) then puts {msg:}
+in BCDD::Failure(type: :division_by_zero, value: {msg:}) then puts msg
+in BCDD::Success(type: :division_completed, value: {num:}) then puts num
+end
+
+# The code above will print: arg1 must be numeric
+```
+
+You can also use `BCDD::Context::Success` and `BCDD::Context::Failure` as patterns.
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+### How to pattern match without the concept of success and failure
+
+You can use the classes `BCDD::Result` and `BCDD::Context` as patterns, and the pattern matching will work without the concept of success and failure.
+
+```ruby
+case Divide.call(10, 2)
+in BCDD::Context(:invalid_arg, {msg:}) then puts msg
+in BCDD::Context(:division_by_zero, {msg:}) then puts msg
+in BCDD::Context(:division_completed, {num:}) then puts num
+end
+
+case Divide.call(10, 2)
+in BCDD::Result(:invalid_arg, msg) then puts msg
+in BCDD::Result(:division_by_zero, msg) then puts msg
+in BCDD::Result(:division_completed, num) then puts num
+end
 ```
 
-### `BCDD::Result.transitions`
+The `BCDD::Result` will also work with the `BCDD::Context`, but the opposite won't.
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+## `BCDD::Result.event_logs`
 
-Use `BCDD::Result.transitions(&block)` to track all transitions in the same or between different operations (it works with `BCDD::Result` and `BCDD::Result::Context`). When there is a nesting of transition blocks, this mechanism will be able to correlate parent and child blocks and present the duration of all operations in milliseconds.
+Use `BCDD::Result.event_logs(&block)` to track all the results produced in the same or between different operations (it works with `BCDD::Result` and `BCDD::Context`). When there is a nesting of `event_logs` blocks, this mechanism will be able to correlate parent and child blocks and present the duration of all operations in milliseconds.
 
-When you wrap the creation of the result with `BCDD::Result.transitions`, the final result will expose all the transition records through the `BCDD::Result#transitions` method.
+When you wrap the creation of the result with `BCDD::Result.event_logs`, the final one will expose all the event log records through the `BCDD::Result#event_logs` method.
 
 ```ruby
 class Division
   include BCDD::Result.mixin(config: { addon: { continue: true } })
 
   def call(arg1, arg2)
-    BCDD::Result.transitions(name: 'Division', desc: 'divide two numbers') do
+    BCDD::Result.event_logs(name: 'Division', desc: 'divide two numbers') do
       Given([arg1, arg2])
         .and_then(:require_numbers)
         .and_then(:check_for_zeros)
@@ -1804,7 +1938,7 @@ class Division
 
   private
 
-  ValidNumber = ->(arg) { arg.is_a?(Numeric) && arg != Float::NAN && arg != Float::INFINITY }
+  ValidNumber = ->(arg) { arg.is_a?(Numeric) && (!arg.respond_to?(:finite?) || arg.finite?) }
 
   def require_numbers((arg1, arg2))
     ValidNumber[arg1] or return Failure(:invalid_arg, 'arg1 must be a valid number')
@@ -1830,7 +1964,7 @@ module SumDivisionsByTwo
   extend self, BCDD::Result.mixin
 
   def call(*numbers)
-    BCDD::Result.transitions(name: 'SumDivisionsByTwo') do
+    BCDD::Result.event_logs(name: 'SumDivisionsByTwo') do
       divisions = numbers.map { |number| Division.new.call(number, 2) }
 
       if divisions.any?(&:failure?)
@@ -1849,85 +1983,90 @@ Let's see the result of the `SumDivisionsByTwo` call:
 result = SumDivisionsByTwo.call(20, 10)
 # => #<BCDD::Result::Success type=:sum value=15>
 
-result.transitions
+result.event_logs
 {
-  :version =>1,
+  :version => 1,
   :metadata => {
-    :duration => 0,                       # milliseconds
-    :tree_map => [0, [[1, []], [2, []]]], # represents the tree of transitions using the id of each transition block
+    :duration => 0,   # milliseconds
+    :trace_id => nil, # can be set through configuration
+    :ids => {
+      :tree => [0, [[1, []], [2, []]]],
+      :matrix => { 0 => [0, 0], 1 => [1, 1], 2 => [2, 1]},
+      :level_parent => { 0 => [0, 0], 1 => [1, 0], 2 => [1, 0]}
+    }
   },
-  :records => [
+  :records=> [
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>1, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:given, :value=>[20, 2]},
-      :and_then=>{},
-      :time=>2024-01-02 03:35:11.248418 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>1, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:_given_, :value=>[20, 2], :source=><Division:0x0000000102fd7ed0>},
+      :and_then => {},
+      :time => 2024-01-26 02:53:11.310346 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>1, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:continued, :value=>[20, 2]},
-      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106099028>, :method_name=>:require_numbers},
-      :time=>2024-01-02 03:35:11.248558 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>1, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:_continue_, :value=>[20, 2], :source=><Division:0x0000000102fd7ed0>},
+      :and_then => {:type=>:method, :arg=>nil, :method_name=>:require_numbers},
+      :time => 2024-01-26 02:53:11.310392 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>1, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:continued, :value=>[20, 2]},
-      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106099028>, :method_name=>:check_for_zeros},
-      :time=>2024-01-02 03:35:11.248587 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>1, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:_continue_, :value=>[20, 2], :source=><Division:0x0000000102fd7ed0>},
+      :and_then => {:type=>:method, :arg=>nil, :method_name=>:check_for_zeros},
+      :time=>2024-01-26 02:53:11.310403 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>1, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:division_completed, :value=>10},
-      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106099028>, :method_name=>:divide},
-      :time=>2024-01-02 03:35:11.248607 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>1, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:division_completed, :value=>10, :source=><Division:0x0000000102fd7ed0>},
+      :and_then => {:type=>:method, :arg=>nil, :method_name=>:divide},
+      :time => 2024-01-26 02:53:11.310409 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>2, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:given, :value=>[10, 2]},
-      :and_then=>{},
-      :time=>2024-01-02 03:35:11.24865 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>2, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:_given_, :value=>[10, 2], :source=><Division:0x0000000102fd6378>},
+      :and_then => {},
+      :time => 2024-01-26 02:53:11.310424 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>2, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:continued, :value=>[10, 2]},
-      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106097ed0>, :method_name=>:require_numbers},
-      :time=>2024-01-02 03:35:11.248661 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>2, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:_continue_, :value=>[10, 2], :source=><Division:0x0000000102fd6378>},
+      :and_then => {:type=>:method, :arg=>nil, :method_name=>:require_numbers},
+      :time => 2024-01-26 02:53:11.310428 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>2, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:continued, :value=>[10, 2]},
-      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106097ed0>, :method_name=>:check_for_zeros},
-      :time=>2024-01-02 03:35:11.248672 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>2, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:_continue_, :value=>[10, 2], :source=><Division:0x0000000102fd6378>},
+      :and_then => {:type=>:method, :arg=>nil, :method_name=>:check_for_zeros},
+      :time => 2024-01-26 02:53:11.310431 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>2, :name=>"Division", :desc=>"divide two numbers"},
-      :result=>{:kind=>:success, :type=>:division_completed, :value=>5},
-      :and_then=>{:type=>:method, :arg=>nil, :source=><Division:0x0000000106097ed0>, :method_name=>:divide},
-      :time=>2024-01-02 03:35:11.248682 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>2, :name=>"Division", :desc=>"divide two numbers"},
+      :result => {:kind=>:success, :type=>:division_completed, :value=>5, :source=><Division:0x0000000102fd6378>},
+      :and_then => {:type=>:method, :arg=>nil, :method_name=>:divide},
+      :time => 2024-01-26 02:53:11.310434 UTC
     },
     {
-      :root=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :parent=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :current=>{:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
-      :result=>{:kind=>:success, :type=>:sum, :value=>15},
-      :and_then=>{},
-      :time=>2024-01-02 03:35:11.248721 UTC
+      :root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :current => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
+      :result => {:kind=>:success, :type=>:sum, :value=>15, :source=>SumDivisionsByTwo},
+      :and_then => {},
+      :time => 2024-01-26 02:53:11.310444 UTC
     }
   ]
 }
@@ -1935,28 +2074,260 @@ result.transitions
 
 <p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
 
-#### Configuration
+### `metadata: {ids:}`
+
+The `:ids` metadata property is a hash with three properties:
+- `:tree`, a graph/tree representation of the id of each `event_logs` block.
+- `:level_parent`, a hash with the level (depth) of each block and its parent id.
+- `:matrix`, a matrix representation of the event logs ids. It is a simplification of the `:tree` property.
 
-You can use `BCDD::Result.config.feature.disable!(:transitions)` and `BCDD::Result.config.feature.enable!(:transitions)` to turn on/off the `BCDD::Result.transitions` feature.
+Use these data structures to build your own visualization.
+
+> Check out [Event Logs Listener example](examples/single_listener/lib/single_event_logs_listener.rb) to see how a listener can be used to build a STDOUT visualization, using these properties.
+
+```ruby
+# tree:
+# A graph representation (array of arrays) of the each event logs block id.
+#
+0                  # [0, [
+|- 1               #   [1, [[2, []]]],
+|  |- 2            #   [3, []],
+|- 3               #   [4, [
+|- 4               #     [5, []],
+|  |- 5            #     [6, [[7, []]]]
+|  |- 6            #   ]],
+|     |- 7         #   [8, []]
+|- 8               # ]]
+
+# level_parent:
+# The event logs ids are the keys, and the level (depth) and parent id the values.
+                   # {
+0                  #   0 => [0, 0],
+|- 1               #   1 => [1, 0],
+|  |- 2            #   2 => [2, 1],
+|- 3               #   3 => [1, 0],
+|- 4               #   4 => [1, 0],
+|  |- 5            #   5 => [2, 4],
+|  |- 6            #   6 => [2, 4],
+|     |- 7         #   7 => [3, 6],
+|- 8               #   8 => [1, 0]
+                   # }
+
+# matrix:
+# The rows are the direct blocks from the root block,
+# and the columns are the nested blocks from the direct ones.
+                   # {
+0 | 1 | 2 | 3 | 4  #   0 => [0, 0],
+- | - | - | - | -  #   1 => [1, 1],
+0 |   |   |   |    #   2 => [1, 2],
+1 | 1 | 2 |   |    #   3 => [2, 1],
+2 | 3 |   |   |    #   4 => [3, 1],
+3 | 4 | 5 | 6 | 7  #   5 => [3, 2],
+4 | 8 |   |   |    #   6 => [3, 3],
+                   #   7 => [3, 4],
+                   #   8 => [4, 1]
+                   # }
+```
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+### Configuration
+
+#### Turning on/off
+
+You can use `BCDD::Result.config.feature.disable!(event_logs)` and `BCDD::Result.config.feature.enable!(event_logs)` to turn on/off the `BCDD::Result.event_logs` feature.
 
 ```ruby
 BCDD::Result.configuration do |config|
-  config.feature.disable!(:transitions)
+  config.feature.disable!(event_logs)
 end
 
 result = SumDivisionsByTwo.call(20, 10)
 # => #<BCDD::Result::Success type=:sum value=15>
 
-result.transitions
+result.event_logs
+{
+  :version=>1,
+  :records=>[],
+  :metadata=>{
+    :duration=>0,
+    :ids=>{:tree=>[], :matrix=>{}, :level_parent=>{}}, :trace_id=>nil
+  }
+}
+```
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+#### Setting a `trace_id` fetcher
 
-{:version=>1, :records=>[], :metadata=>{:duration=>0, :tree_map=>[]}}
+You can define a lambda (arity 0) to fetch the trace_id. This lambda will be called before the first event logs block and will be used to set the `:trace_id` in the `:metadata` property.
+
+Use to correlate different or the same operation (executed multiple times).
+
+```ruby
+BCDD::Result.config.event_logs.trace_id = -> { Thread.current[:bcdd_result_event_logs_trace_id] }
 ```
 
 <p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
 
-### `BCDD::Result.configuration`
+#### Setting a `listener`
+
+You can define a listener to be called during the event logs tracking (check out [this example](examples/single_listener/lib/single_event_logs_listener.rb)). It must be a class that includes `BCDD::Result::EventLogs::Listener`.
+
+Use it to build your additional logic on top of the tracking. Examples:
+  - Log the event  logs.
+  - Perform the tracing.
+  - Instrument the event logs (measure/report).
+  - Build a visualization (Diagrams, using the `records:` + `metadata: {ids:}` properties).
+
+After implementing your listener, you can set it to the `BCDD::Result.config.event_logs.listener=`:
+
+```ruby
+BCDD::Result.config.event_logs.listener = MyEventLogsListener
+```
 
-The `BCDD::Result.configuration` allows you to configure default behaviors for `BCDD::Result` and `BCDD::Result::Context` through a configuration block. After using it, the configuration is frozen, ensuring the expected behaviors for your application.
+See the example below to understand how to implement one:
+
+```ruby
+class MyEventLogsListener
+  include BCDD::Result::EventLogs::Listener
+
+  # A listener will be initialized before the first event logs block, and it is discarded after the last one.
+  def initialize
+  end
+
+  # This method will be called before each event logs block.
+  # The parent block will be called first in the case of nested ones.
+  #
+  # @param scope: {:id=>1, :name=>"SomeOperation", :desc=>"Optional description"}
+  def on_start(scope:)
+  end
+
+  # This method will wrap all the event logs in the same block.
+  # It can be used to perform an instrumentation (measure/report).
+  #
+  # @param scope: {:id=>1, :name=>"SomeOperation", :desc=>"Optional description"}
+  def around_event_logs(scope:)
+    yield
+  end
+
+  # This method will wrap each and_then call.
+  # It can be used to perform an instrumentation of the and_then calls.
+  #
+  # @param scope: {:id=>1, :name=>"SomeOperation", :desc=>"Optional description"}
+  # @param and_then:
+  #  {:type=>:block, :arg=>:some_injected_value}
+  #  {:type=>:method, :arg=>:some_injected_value, :method_name=>:some_method_name}
+  def around_and_then(scope:, and_then:)
+    yield
+  end
+
+  # This method will be called after each result recording/tracking.
+  #
+  # @param record:
+  # {
+  #   :root => {:id=>0, :name=>"RootOperation", :desc=>nil},
+  #   :parent => {:id=>0, :name=>"RootOperation", :desc=>nil},
+  #   :current => {:id=>1, :name=>"SomeOperation", :desc=>nil},
+  #   :result => {:kind=>:success, :type=>:_continue_, :value=>{some: :thing}, :source=><MyProcess:0x0000000102fd6378>},
+  #   :and_then => {:type=>:method, :arg=>nil, :method_name=>:some_method},
+  #   :time => 2024-01-26 02:53:11.310431 UTC
+  # }
+  def on_record(record:)
+  end
+
+  # This method will be called at the end of the event logs tracking.
+  #
+  # @param event_logs:
+  # {
+  #   :version => 1,
+  #   :metadata => {
+  #     :duration => 0,
+  #     :trace_id => nil,
+  #     :ids => {
+  #       :tree => [0, [[1, []], [2, []]]],
+  #       :matrix => { 0 => [0, 0], 1 => [1, 1], 2 => [2, 1]},
+  #       :level_parent => { 0 => [0, 0], 1 => [1, 0], 2 => [1, 0]}
+  #     }
+  #   },
+  #   :records => [
+  #     # ...
+  #   ]
+  # }
+  def on_finish(event_logs:)
+  end
+
+  # This method will be called when an exception is raised during the event logs tracking.
+  #
+  # @param exception: Exception
+  # @param event_logs: Hash
+  def before_interruption(exception:, event_logs:)
+  end
+end
+```
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+#### Setting multiple `listeners`
+
+You can use `BCDD::Result::EventLogs::Listeners[]` to creates a listener of listeners (check out [this example](examples/multiple_listeners/Rakefile)), which will be called in the order they were added.
+
+**Attention:** It only allows one listener to handle `around_and_then` and another `around_event_logs` records.
+
+> The example below defines different listeners to handle `around_and_then` and `around_event_logs,` but it is also possible to define a listener to handle both.
+
+```ruby
+class AroundAndThenListener
+  include BCDD::Result::EventLogs::Listener
+
+  # It must be a static/singleton method.
+  def self.around_and_then?
+    true
+  end
+
+  def around_and_then(scope:, and_then:)
+    #...
+  end
+end
+
+class AroundEventLogsListener
+  include BCDD::Result::EventLogs::Listener
+
+  # It must be a static/singleton method.
+  def self.around_event_logs?
+    true
+  end
+
+  def around_event_logs(scope:)
+    #...
+  end
+end
+
+class MyEventLogsListener
+  include BCDD::Result::EventLogs::Listener
+end
+```
+
+How to use it:
+
+```ruby
+# The listeners will be called in the order they were added.
+BCDD::Result.config.event_logs.listener = BCDD::Result::EventLogs::Listeners[
+  MyEventLogsListener,
+  AroundAndThenListener,
+  AroundEventLogsListener
+]
+```
+
+> Check out [this example](examples/multiple_listeners) to see a listener to print the event logs and another to store them in the database.
+
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
+## `BCDD::Result.configuration`
+
+The `BCDD::Result.configuration` allows you to configure default behaviors for `BCDD::Result` and `BCDD::Context` through a configuration block. After using it, the configuration is frozen, ensuring the expected behaviors for your application.
+
+> Note: You can use `BCDD::Result.configuration(freeze: false) {}` to avoid the freezing. This can be useful in tests. Please be sure to use it with caution.
 
 ```ruby
 BCDD::Result.configuration do |config|
@@ -1974,37 +2345,37 @@ Use `disable!` to disable a feature and `enable!` to enable it.
 
 Let's see what each configuration in the example above does:
 
-#### `config.addon.enable!(:given, :continue)`
+### `config.addon.enable!(:given, :continue)` <!-- omit in toc -->
 
-This configuration enables the `Continue()` method for `BCDD::Result.mixin`, `BCDD::Result::Context.mixin`, `BCDD::Result::Expectation.mixin`, and `BCDD::Result::Context::Expectation.mixin`. Link to documentations: [(1)](#add-ons) [(2)](#mixin-add-ons).
+This configuration enables the `Continue()` method for `BCDD::Result.mixin`, `BCDD::Context.mixin`, `BCDD::Result::Expectation.mixin`, and `BCDD::Context::Expectation.mixin`. Link to documentations: [(1)](#add-ons) [(2)](#mixin-add-ons).
 
 It is also enabling the `Given()` which is already enabled by default. Link to documentation: [(1)](#add-ons) [(2)](#mixin-add-ons).
 
-#### `config.constant_alias.enable!('Result', 'BCDD::Context')`
+### `config.constant_alias.enable!('Result', 'BCDD::Context')` <!-- omit in toc -->
 
-This configuration make `Result` a constant alias for `BCDD::Result`, and `BCDD::Context` a constant alias for `BCDD::Result::Context`.
+This configuration make `Result` a constant alias for `BCDD::Result`, and `BCDD::Context` a constant alias for `BCDD::Context`.
 
 Link to documentations:
 - [Result alias](#bcddresult-versus-result)
 - [Context aliases](#constant-aliases)
 
-#### `config.pattern_matching.disable!(:nil_as_valid_value_checking)`
+### `config.pattern_matching.disable!(:nil_as_valid_value_checking)` <!-- omit in toc -->
 
-This configuration disables the `nil_as_valid_value_checking` for `BCDD::Result` and `BCDD::Result::Context`. Link to [documentation](#pattern-matching-support).
+This configuration disables the `nil_as_valid_value_checking` for `BCDD::Result` and `BCDD::Context`. Link to [documentation](#pattern-matching-support).
 
-<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
-
-#### `config.feature.disable!(:expectations)`
+### `config.feature.disable!(:expectations)` <!-- omit in toc -->
 
-This configuration turns off the expectations for `BCDD::Result` and `BCDD::Result::Context`. The expectations are helpful in development and test environments, but they can be disabled in production environments for performance gain.
+This configuration turns off the expectations for `BCDD::Result` and `BCDD::Context`. The expectations are helpful in development and test environments, but they can be disabled in production environments for performance gain.
 
 PS: I'm using `::Rails.env.production?` to check the environment, but you can use any logic you want.
 
+<p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>
+
 ### `BCDD::Result.config`
 
 The `BCDD::Result.config` allows you to access the current configuration.
 
-**BCDD::Result.config.addon**
+#### **BCDD::Result.config.addon** <!-- omit in toc -->
 
 ```ruby
 BCDD::Result.config.addon.enabled?(:continue)
@@ -2016,24 +2387,24 @@ BCDD::Result.config.addon.options
 #     :enabled=>false,
 #     :affects=>[
 #       "BCDD::Result.mixin",
-#       "BCDD::Result::Context.mixin",
+#       "BCDD::Context.mixin",
 #       "BCDD::Result::Expectations.mixin",
-#       "BCDD::Result::Context::Expectations.mixin"
+#       "BCDD::Context::Expectations.mixin"
 #     ]
 #   },
 #   :given=>{
 #     :enabled=>true,
 #     :affects=>[
 #       "BCDD::Result.mixin",
-#       "BCDD::Result::Context.mixin",
+#       "BCDD::Context.mixin",
 #       "BCDD::Result::Expectations.mixin",
-#       "BCDD::Result::Context::Expectations.mixin"
+#       "BCDD::Context::Expectations.mixin"
 #     ]
 #   }
 # }
 ```
 
-**BCDD::Result.config.constant_alias**
+#### **BCDD::Result.config.constant_alias** <!-- omit in toc -->
 
 ```ruby
 BCDD::Result.config.constant_alias.enabled?('Result')
@@ -2048,7 +2419,7 @@ BCDD::Result.config.constant_alias.options
 # }
 ```
 
-**BCDD::Result.config.pattern_matching**
+#### **BCDD::Result.config.pattern_matching** <!-- omit in toc -->
 
 ```ruby
 BCDD::Result.config.pattern_matching.enabled?(:nil_as_valid_value_checking)
@@ -2059,13 +2430,13 @@ BCDD::Result.config.pattern_matching.options
 #     :enabled=>false,
 #     :affects=>[
 #       "BCDD::Result::Expectations,
-#       "BCDD::Result::Context::Expectations"
+#       "BCDD::Context::Expectations"
 #     ]
 #   }
 # }
 ```
 
-**BCDD::Result.config.feature**
+#### **BCDD::Result.config.feature** <!-- omit in toc -->
 
 ```ruby
 BCDD::Result.config.feature.enabled?(:expectations)
@@ -2076,21 +2447,21 @@ BCDD::Result.config.feature.options
 #     :enabled=>true,
 #     :affects=>[
 #       "BCDD::Result::Expectations,
-#       "BCDD::Result::Context::Expectations"
+#       "BCDD::Context::Expectations"
 #     ]
 #   },
-#   :transitions=>{
+#   event_logs=>{
 #     :enabled=>true,
 #     :affects=>[
 #       "BCDD::Result",
-#       "BCDD::Result::Context"
+#       "BCDD::Context"
 #     ]
 #   },
 #   :and_then!=>{
 #     :enabled=>false,
 #     :affects=>[
 #       "BCDD::Result",
-#       "BCDD::Result::Context"
+#       "BCDD::Context"
 #     ]
 #   },
 # }
@@ -2133,7 +2504,7 @@ class PlaceOrder < Micro::Case
 end
 ```
 
-To facilitate migration for users accustomed to the above approaches, `bcdd-result` includes the `BCDD::Result#and_then!`/`BCDD::Result::Context#and_then!` methods, which will invoke the method `call` of the given operation and expect it to return a `BCDD::Result`/`BCDD::Result::Context` object.
+To facilitate migration for users accustomed to the above approaches, `bcdd-result` includes the `BCDD::Result#and_then!`/`BCDD::Context#and_then!` methods, which will invoke the method `call` of the given operation and expect it to return a `BCDD::Result`/`BCDD::Context` object.
 
 ```ruby
 BCDD::Result.configure do |config|
@@ -2141,7 +2512,7 @@ BCDD::Result.configure do |config|
 end
 
 class PlaceOrder
-  include BCDD::Result::Context.mixin
+  include BCDD::Context.mixin
 
   def call(**input)
     Given(input)
@@ -2173,11 +2544,11 @@ class PlaceOrder
 end
 ```
 
-**In BCDD::Result::Context**
+**In BCDD::Context**
 
 ```ruby
 class PlaceOrder
-  include BCDD::Result::Context.mixin
+  include BCDD::Context.mixin
 
   def call(logger:, **input)
     Given(input)
@@ -2231,7 +2602,7 @@ Attention: to ensure the correct behavior, do not mix `#and_then` and `#and_then
 
 #### Analysis: Why is `#and_then` the antidote/standard?
 
-The `BCDD::Result#and_then`/`BCDD::Result::Context#and_then` methods diverge from the above approach by requiring explicit invocation and mapping of the outcomes at each process step. This approach has the following advantages:
+The `BCDD::Result#and_then`/`BCDD::Context#and_then` methods diverge from the above approach by requiring explicit invocation and mapping of the outcomes at each process step. This approach has the following advantages:
 
 - **Clarity:** The input/output relationship between the steps is apparent and highly understandable.
 
@@ -2241,7 +2612,7 @@ See this example to understand what your code should look like:
 
 ```ruby
 class PlaceOrder
-  include BCDD::Result::Context.mixin(config: { addon: { continue: true } })
+  include BCDD::Context.mixin(config: { addon: { continue: true } })
 
   def call(**input)
     Given(input)
@@ -2287,7 +2658,7 @@ end
 
 ## About
 
-[Rodrigo Serradura](https://github.com/serradura) created this project. He is the B/CDD process/method creator and has already made similar gems like the [u-case](https://github.com/serradura/u-case) and [kind](https://github.com/serradura/kind/blob/main/lib/kind/result.rb). This gem is a general-purpose abstraction/monad, but it also contains key features that serve as facilitators for adopting B/CDD in the code.
+[Rodrigo Serradura](https://github.com/serradura) created this project. He is the B/CDD process/method creator and has already made similar gems like the [u-case](https://github.com/serradura/u-case) and [kind](https://github.com/serradura/kind/blob/main/lib/kind/result.rb). This gem can be used independently, but it also contains essential features that facilitate the adoption of B/CDD in code.
 
 <p align="right"><a href="#-bcddresult">⬆️ &nbsp;back to top</a></p>