easyop 0.1.4 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b880af1b623158d3acfac130198bd96ce8c268195fd073554283738a880a45a
-  data.tar.gz: 0c4f5554b456ac252b13734d0964155e2a80909e81946e28f89c529cc60f9081
+  metadata.gz: 5fda2bb2b17350fc5da2939e9bc4ec4bd816c2e9828f440adcf6750555f02e06
+  data.tar.gz: af2eb053c15796a702dc01b6a44ebacbd15ec644ff5dce1e7fd97734e9e35199
 SHA512:
-  metadata.gz: c408d6d42a357ba1a6df4da21e13a7b0498d36fa4252e86c68aff289e8843d94d056c430f654f023e6d801ee650fc1bc4c400cb6d058a6b209129e1fbda644fd
-  data.tar.gz: e89087c84c8fbc77abe96b6713a144dd34b78c2cfd35066f28a14e37516f0e7ae8b0f0cbbcfe0ca9eb9de646c7890552b64d7d2848c9976ff6f51637531a4a8a
+  metadata.gz: a9461b76dfd41ad12bf5a14b5e2e0a1f59a073402a23a5f89d3b5f773314c63b290e8d15e946394c013f73717a97ba51df717e861d6e9d67cb3109c243e32e25
+  data.tar.gz: 5d1387e43e468478267f29bca65289652a092b1727355f48b71604863daf35933d0199bb810729ac07abdf57deaf0e264febab3e0e3fca6bd3a2ed71584335be

data/CHANGELOG.md

@@ -7,6 +7,134 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.7] — 2026-04-15
+
+### Added
+
+- **`execution_index` for `Easyop::Plugins::Recording`** — an optional `:integer` column that records the 1-based call order of each child operation within its parent. Root operations store `nil`. Each child's counter resets independently under its own parent, so siblings of different parents both start at `1`. Add via migration:
+
+  ```ruby
+  add_column :operation_logs, :execution_index, :integer
+  add_index  :operation_logs, [:parent_reference_id, :execution_index],
+             name: 'index_operation_logs_on_parent_ref_and_exec_index'
+  ```
+
+  Example tree:
+  ```
+  FullCheckout  (execution_index: nil — root)
+    ValidateCart    (execution_index: 1)
+    ApplyDiscount   (execution_index: 2)
+      LookupCode    (execution_index: 1)  ← resets under new parent
+      DeductAmt     (execution_index: 2)
+    CreateOrder     (execution_index: 3)
+  ```
+
+  The column is fully optional and backward-compatible — missing columns are silently skipped.
+
+## [0.1.6] — 2026-04-15
+
+### Added
+
+- **`record_result: true` form for `Easyop::Plugins::Recording`** — passing `true` at install time (or via the class-level `record_result true` DSL) now records the full ctx snapshot after the operation completes. `FILTERED_KEYS` are applied and `INTERNAL_CTX_KEYS` are excluded. The `true` form captures computed values set during `#call`, making it a full output snapshot.
+
+- **`record_params` class-level DSL** — parallel to `record_result`, operations can now declare params recording behaviour per-class:
+
+  ```ruby
+  record_params false                          # disable params recording entirely
+  record_params attrs: %i[email name]          # selective keys only
+  record_params { |ctx| { id: ctx.user_id } }  # block form
+  record_params :build_safe_params             # private method form
+  record_params true                           # explicit full ctx (default)
+  ```
+
+  Inherited through the class hierarchy; subclasses can override.
+
+- **`record_params:` install option extended** — the `plugin Easyop::Plugins::Recording, record_params:` option now accepts the same forms as the DSL: `false`, `true`, `{ attrs: }`, `Proc`, `Symbol`.
+
+- **Input-only `params_data` by default** — when `record_params` is `true` (the default), `params_data` now records only the keys that were present in `ctx` **before** the operation body ran. Computed values written during `#call` are excluded from `params_data`. Custom forms (attrs/block/symbol) are user-controlled and evaluated after the call, so they can access computed values.
+
+### Changed
+
+- **`record_result` default is now `false`** — previously defaulted to `nil` (falsy). Explicit `false` makes intent clear and prevents accidental result logging.
+
+## [0.1.5] — 2026-04-14
+
+### Added
+
+- **`filter_params` DSL for `Easyop::Plugins::Recording`** — declare additional params keys/patterns to filter in `params_data` on a per-class basis. Matched keys are kept but their value is replaced with `"[FILTERED]"`. Accepts `Symbol`, `String`, or `Regexp`. Additive with `FILTERED_KEYS` and never replaces the built-in list. Inherited by subclasses; any level of the hierarchy can override.
+
+  ```ruby
+  class ApplicationOperation < ...
+    filter_params :api_token, /access.?key/i
+  end
+
+  class Orders::CreateOrder < ApplicationOperation
+    filter_params :card_number   # stacks on top of parent's filter list
+  end
+  ```
+
+- **`filter_keys:` option on `plugin Easyop::Plugins::Recording`** — supply a list of extra keys/patterns to filter at plugin install time. Inherited by all classes that share the same `plugin` declaration.
+
+  ```ruby
+  plugin Easyop::Plugins::Recording,
+         model: OperationLog,
+         filter_keys: [:stripe_token, /secret/i]
+  ```
+
+- **`Easyop::Configuration#recording_filter_keys`** — new global config key. Set once at boot and every recorded operation will filter these keys in addition to `FILTERED_KEYS` and any class-level declarations. Accepts `Symbol`, `String`, or `Regexp`.
+
+  ```ruby
+  Easyop.configure do |c|
+    c.recording_filter_keys = [:api_token, /token/i]
+  end
+  ```
+
+- **`[FILTERED]` value replacement** — sensitive keys are now kept in `params_data` with their value replaced by `"[FILTERED]"` instead of being removed entirely. This means audit logs show *which* sensitive fields were passed without exposing their values.
+
+  **Filter precedence (all layers are additive):**
+  1. `FILTERED_KEYS` — always applied (built-in list)
+  2. `Easyop.config.recording_filter_keys` — global config
+  3. `filter_keys:` plugin option + `filter_params` DSL — class hierarchy
+
+- **`params_data` records only input keys by default** — `params_data` now snapshots the ctx keys present *before* the operation body runs. Values computed during `#call` (e.g. `ctx.user = User.create!(...)`) are excluded from `params_data`; use `record_result` to capture them. Custom `record_params` forms (attrs, block, symbol) are evaluated *after* the call and can access computed values when explicitly requested. FILTERED_KEYS and INTERNAL_CTX_KEYS are always excluded.
+
+- **`record_result: true` form** — passing `true` records the full ctx snapshot (all non-internal keys, FILTERED_KEYS applied). Works at both the plugin install level and the class-level DSL.
+
+  ```ruby
+  # Plugin level — all operations inherit this default
+  plugin Easyop::Plugins::Recording, model: OperationLog, record_result: true
+
+  # Class level DSL
+  class Orders::CreateOrder < ApplicationOperation
+    record_result true
+  end
+  ```
+
+- **`record_params` class-level DSL** — parallel to `record_result`, `record_params` can now be declared on any class to control what ends up in `params_data`. Supports four forms:
+
+  ```ruby
+  record_params false                            # disable params entirely
+  record_params true                             # explicit full ctx (default)
+  record_params attrs: :user_id                  # selective keys
+  record_params attrs: [:user_id, :event_id]
+  record_params { |ctx| { custom: ctx[:name] } } # block
+  record_params :build_params                    # private method name
+  ```
+
+  FILTERED_KEYS are **always applied** to the extracted hash regardless of form (keys are kept, values replaced with `"[FILTERED]"`). Config is inheritable and overridable per subclass.
+
+- **`record_params:` install option extended** — the plugin install-level `record_params:` option now accepts the same forms as the DSL: `Hash` (`{ attrs: }` ), `Proc`, and `Symbol`, in addition to `true`/`false`.
+
+  ```ruby
+  plugin Easyop::Plugins::Recording,
+         model: OperationLog,
+         record_params: { attrs: %i[user_id plan] }
+  ```
+
+### Changed
+
+- **`record_result` default is now `false`** (was `nil`). Behaviour is identical — no `result_data` is written unless explicitly configured — but the default value is now consistent with the boolean-style `record_params: true` API convention.
+
 ## [0.1.4] — 2026-04-14
 
 ### Added
@@ -258,6 +386,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `examples/easyop_test_app/` — full Rails 8 blog application demonstrating all features in real-world code
 - `examples/usage.rb` — 13 runnable plain-Ruby examples
 
-[Unreleased]: https://github.com/pniemczyk/easyop/compare/v0.1.4...HEAD
+[Unreleased]: https://github.com/pniemczyk/easyop/compare/v0.1.7...HEAD
+[0.1.7]: https://github.com/pniemczyk/easyop/compare/v0.1.6...v0.1.7
+[0.1.6]: https://github.com/pniemczyk/easyop/compare/v0.1.5...v0.1.6
+[0.1.5]: https://github.com/pniemczyk/easyop/compare/v0.1.4...v0.1.5
 [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

data/README.md

@@ -645,8 +645,9 @@ end
 | Option | Default | Description |
 |---|---|---|
 | `model:` | required | ActiveRecord class to write logs into |
-| `record_params:` | `true` | Set `false` to skip serializing ctx params |
-| `record_result:` | `nil` | Plugin-level default for result capture (Hash/Proc/Symbol — see below) |
+| `record_params:` | `true` | Control params serialization: `false` skips it; `true` uses full ctx; also accepts `{ attrs: }`, `Proc`, or `Symbol` |
+| `record_result:` | `false` | Plugin-level default for result capture: `false` skips; `true` uses full ctx; also accepts `{ attrs: }`, `Proc`, or `Symbol` |
+| `filter_keys:` | `[]` | Extra keys/patterns to filter in `params_data` (Symbol, String, Regexp) — values replaced with `[FILTERED]` |
 
 **Required model columns:**
 
@@ -655,9 +656,12 @@ create_table :operation_logs do |t|
   t.string   :operation_name, null: false
   t.boolean  :success,        null: false
   t.string   :error_message
-  t.text     :params_data          # JSON — ctx attrs (sensitive keys scrubbed)
+  t.text     :params_data          # JSON — ctx attrs (sensitive keys replaced with [FILTERED])
   t.float    :duration_ms
   t.datetime :performed_at,   null: false
+
+  # Optional — add when using the record_result DSL to capture output data:
+  t.text     :result_data          # JSON — selected ctx keys after the operation runs
 end
 ```
 
@@ -696,7 +700,65 @@ root_log = OperationLog.find_by(operation_name: "FullCheckout", parent_reference
 OperationLog.for_tree(root_log.root_reference_id)
 ```
 
-The plugin automatically scrubs these keys from `params_data` before persisting: `:password`, `:password_confirmation`, `:token`, `:secret`, `:api_key`. ActiveRecord objects are serialized as `{ id:, class: }` rather than their full representation.
+**Filtering params** — sensitive keys are kept in `params_data` but their value is replaced with `"[FILTERED]"`, so the audit log shows which fields were passed without exposing their values. All layers are additive:
+
+1. **Built-in `FILTERED_KEYS`** — always applied: `:password`, `:password_confirmation`, `:token`, `:secret`, `:api_key`
+2. **Global config** — applied to every recorded operation:
+   ```ruby
+   Easyop.configure { |c| c.recording_filter_keys = [:api_token, /token/i] }
+   ```
+3. **Plugin `filter_keys:` option** — applied to all subclasses that share the plugin install:
+   ```ruby
+   plugin Easyop::Plugins::Recording, model: OperationLog, filter_keys: [:stripe_secret]
+   ```
+4. **`filter_params` DSL** — per-class, inheritable, and stackable at any level of the hierarchy:
+   ```ruby
+   class ApplicationOperation < ...
+     filter_params :internal_token, /access.?key/i
+   end
+   class Payments::ChargeCard < ApplicationOperation
+     filter_params :card_number   # stacks on top of parent's list
+   end
+   ```
+
+Internal tracing keys (`__recording_*`) are always fully removed. ActiveRecord objects are serialized as `{ id:, class: }` rather than their full representation.
+
+**`record_params` DSL — control what goes into `params_data`:**
+
+By default, `params_data` records only the keys that were **present in ctx when the operation was called** (inputs), not values computed during the call body. This means `ctx.user = User.create!(...)` set during `#call` will not appear in `params_data` — use `record_result` to capture output values. FILTERED_KEYS and INTERNAL_CTX_KEYS are always excluded.
+
+Use the `record_params` DSL to further customize or suppress params recording:
+
+```ruby
+# Disable entirely — no params_data written
+class Users::Authenticate < ApplicationOperation
+  record_params false
+end
+
+# Selective keys — only these ctx attrs are recorded
+class Tickets::GenerateTickets < ApplicationOperation
+  record_params attrs: %i[event_id seat_count]
+end
+
+# Block — full control over the extracted hash
+class Reports::GeneratePdf < ApplicationOperation
+  record_params { |ctx| { report_type: ctx.report_type, page_count: ctx.pages } }
+end
+
+# Symbol — delegates to a private method on the instance
+class Payments::ChargeCard < ApplicationOperation
+  record_params :safe_params
+
+  private
+  def safe_params
+    { user_id: ctx.user.id, amount_cents: ctx.amount_cents }
+  end
+end
+```
+
+FILTERED_KEYS are **always applied** to the extracted hash regardless of form — including custom attrs, blocks, and symbol methods. Plugin install-level `record_params:` accepts the same forms as the DSL.
+
+> **Input vs. output**: The `true` (default) form records only keys present *before* the call body runs — values computed during `#call` (like `ctx.user`) are excluded. Custom forms (attrs, block, symbol) are evaluated *after* the call, so they can access computed values. Use `record_result` to capture outputs alongside inputs.
 
 **`record_result` DSL — capture output data:**
 
@@ -706,9 +768,14 @@ Add an optional `result_data :text` column to persist selected ctx values after
 add_column :operation_logs, :result_data, :text  # stored as JSON
 ```
 
-Then declare what to record using the `record_result` DSL (three forms):
+Then declare what to record using the `record_result` DSL (four forms):
 
 ```ruby
+# True form — full ctx snapshot (FILTERED_KEYS applied, internal keys excluded)
+class Users::Register < ApplicationOperation
+  record_result true
+end
+
 # Attrs form — one or more ctx keys
 class PlaceOrder < ApplicationOperation
   record_result attrs: :order_id
@@ -739,7 +806,8 @@ Set a plugin-level default inherited by all subclasses:
 
 ```ruby
 plugin Easyop::Plugins::Recording, model: OperationLog,
-       record_result: { attrs: :metadata }
+       record_result: true
+# or: record_result: { attrs: :metadata }
 # or: record_result: ->(ctx) { { id: ctx.record_id } }
 # or: record_result: :build_result
 ```
@@ -1459,7 +1527,7 @@ Edit `lib/easyop/version.rb` and increment the version string following [Semanti
 ```ruby
 # lib/easyop/version.rb
 module Easyop
-  VERSION = "0.1.4"   # was 0.1.3
+  VERSION = "0.1.5"   # was 0.1.4
 end
 ```
 
@@ -1470,45 +1538,45 @@ In `CHANGELOG.md`, move everything under `[Unreleased]` into a new versioned sec
 ```markdown
 ## [Unreleased]
 
-## [0.1.4] — YYYY-MM-DD   # ← new section
+## [0.1.5] — YYYY-MM-DD   # ← new section
 
 ### Added
 - …
 
-## [0.1.3] — 2026-04-14
+## [0.1.4] — 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
+[Unreleased]: https://github.com/pniemczyk/easyop/compare/v0.1.5...HEAD
+[0.1.5]: https://github.com/pniemczyk/easyop/compare/v0.1.4...v0.1.5
 [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"
+git commit -m "Release v0.1.5"
 ```
 
 ### 4. Tag the commit
 
 ```bash
-git tag -a v0.1.4 -m "Release v0.1.4"
+git tag -a v0.1.5 -m "Release v0.1.5"
 ```
 
 ### 5. Push the commit and tag
 
 ```bash
 git push origin master
-git push origin v0.1.4
+git push origin v0.1.5
 ```
 
 ### 6. Build and push the gem (optional)
 
 ```bash
 gem build easyop.gemspec
-gem push easyop-0.1.4.gem
+gem push easyop-0.1.5.gem
 ```

data/lib/easyop/configuration.rb

@@ -15,10 +15,20 @@ module Easyop
     #   Easyop.configure { |c| c.event_bus = :active_support }
     attr_accessor :event_bus
 
+    # Extra keys to filter from params_data across all recorded operations.
+    # Appended to Recording::FILTERED_KEYS — never replaces the built-in list.
+    # Matched keys are kept in params_data but their value is replaced with "[FILTERED]".
+    # Accepts Symbol, String, or Regexp (matched against the stringified key name).
+    #
+    # @example
+    #   Easyop.configure { |c| c.recording_filter_keys = [:api_token, /token/i] }
+    attr_accessor :recording_filter_keys
+
     def initialize
-      @type_adapter = :native
-      @strict_types = false
-      @event_bus    = nil  # nil = Memory bus (see Easyop::Events::Registry)
+      @type_adapter          = :native
+      @strict_types          = false
+      @event_bus             = nil  # nil = Memory bus (see Easyop::Events::Registry)
+      @recording_filter_keys = []
     end
   end
 

data/lib/easyop/plugins/recording.rb

@@ -29,6 +29,9 @@ module Easyop
     # Optional result column:
     #   result_data           :text     # stored as JSON — selected ctx keys after call
     #
+    # Optional execution order column:
+    #   execution_index       :integer  # nil for root; 1-based within each parent
+    #
     # Opt out per operation class:
     #   class MyOp < ApplicationOperation
     #     recording false
@@ -36,25 +39,34 @@ module Easyop
     #
     # Options:
     #   model:         (required) ActiveRecord class
-    #   record_params: true       pass false to skip params serialization
-    #   record_result: nil        configure result capture at plugin level (Hash/Proc/Symbol)
+    #   record_params: true       pass false to skip params serialization; also accepts
+    #                             Hash ({ attrs: :key }), Proc, or Symbol (method name)
+    #   record_result: false      configure result capture at plugin level; also accepts
+    #                             true (full ctx snapshot), Hash, Proc, or Symbol
+    #   filter_keys:   []         additional keys/patterns to filter from params_data
+    #                             (Symbol, String, or Regexp — additive with FILTERED_KEYS)
+    #                             Filtered keys are kept in params_data but their value
+    #                             is replaced with "[FILTERED]".
     module Recording
-      # Sensitive keys scrubbed from params_data before persisting.
-      SCRUBBED_KEYS = %i[password password_confirmation token secret api_key].freeze
+      # Sensitive keys always filtered in params_data before persisting.
+      # Their values are replaced with "[FILTERED]" rather than removed.
+      FILTERED_KEYS = %i[password password_confirmation token secret api_key].freeze
 
       # Internal ctx keys used for flow tracing — excluded from params_data.
       INTERNAL_CTX_KEYS = %i[
         __recording_root_reference_id
         __recording_parent_operation_name
         __recording_parent_reference_id
+        __recording_child_counts
       ].freeze
 
-      def self.install(base, model:, record_params: true, record_result: nil, **_options)
+      def self.install(base, model:, record_params: true, record_result: false, filter_keys: [], **_options)
         base.extend(ClassMethods)
         base.prepend(RunWrapper)
-        base.instance_variable_set(:@_recording_model,         model)
+        base.instance_variable_set(:@_recording_model,          model)
         base.instance_variable_set(:@_recording_record_params,  record_params)
         base.instance_variable_set(:@_recording_record_result,  record_result)
+        base.instance_variable_set(:@_recording_filter_keys,    Array(filter_keys))
       end
 
       module ClassMethods
@@ -73,30 +85,48 @@ module Easyop
             (superclass.respond_to?(:_recording_model) ? superclass._recording_model : nil)
         end
 
-        def _recording_record_params?
+        # DSL for controlling params capture. Forms:
+        #   record_params false           # disable params recording entirely
+        #   record_params true            # explicit full ctx (default)
+        #   record_params attrs: :key     # selective keys
+        #   record_params { |ctx| {...} } # block
+        #   record_params :build_params   # private method name
+        def record_params(value = nil, attrs: nil, &block)
+          @_recording_record_params = if block
+            block
+          elsif attrs
+            { attrs: attrs }
+          elsif !value.nil?
+            value
+          else
+            true
+          end
+        end
+
+        def _recording_record_params_config
           if instance_variable_defined?(:@_recording_record_params)
             @_recording_record_params
-          elsif superclass.respond_to?(:_recording_record_params?)
-            superclass._recording_record_params?
+          elsif superclass.respond_to?(:_recording_record_params_config)
+            superclass._recording_record_params_config
           else
             true
           end
         end
 
-        # DSL for capturing result data after the operation runs.
-        # Three forms:
-        #   record_result attrs: :key           # one or more ctx keys
-        #   record_result { |ctx| { k: ctx.k } } # block
-        #   record_result :build_result         # private instance method name
+        # DSL for capturing result data after the operation runs. Forms:
+        #   record_result true            # full ctx snapshot (FILTERED_KEYS applied)
+        #   record_result attrs: :key     # one or more ctx keys
+        #   record_result { |ctx| {...} } # block
+        #   record_result :build_result   # private instance method name
         def record_result(value = nil, attrs: nil, &block)
           @_recording_record_result = if block
             block
           elsif attrs
             { attrs: attrs }
-          elsif value.is_a?(Symbol)
+          elsif !value.nil?
             value
           else
-            value
+            nil
           end
         end
 
@@ -106,9 +136,36 @@ module Easyop
           elsif superclass.respond_to?(:_recording_record_result_config)
             superclass._recording_record_result_config
           else
-            nil
+            false
           end
         end
+
+        # DSL to declare additional keys/patterns to filter in params_data.
+        # Accepts Symbol, String, or Regexp. Additive with FILTERED_KEYS and
+        # any filter_keys declared on parent classes or at the plugin install level.
+        # Matched keys are kept in params_data but their value is replaced with "[FILTERED]".
+        #
+        # @example
+        #   class ApplicationOperation < ...
+        #     filter_params :api_token, /access.?key/i
+        #   end
+        def filter_params(*keys)
+          @_recording_filter_keys = _own_recording_filter_keys + keys
+        end
+
+        # Returns the merged filter list: parent class keys + this class's own keys.
+        # Does NOT include FILTERED_KEYS or the global config list — those are
+        # merged at persist time so they stay hot-reloadable.
+        def _recording_filter_keys
+          parent = superclass.respond_to?(:_recording_filter_keys) ? superclass._recording_filter_keys : []
+          parent + _own_recording_filter_keys
+        end
+
+        private
+
+        def _own_recording_filter_keys
+          instance_variable_defined?(:@_recording_filter_keys) ? @_recording_filter_keys : []
+        end
       end
 
       module RunWrapper
@@ -117,6 +174,12 @@ module Easyop
           return super unless (model = self.class._recording_model)
           return super unless self.class.name # skip anonymous classes
 
+          # Snapshot the keys present in ctx RIGHT NOW — before any internal
+          # tracing keys are written and before the operation body runs. This
+          # lets _recording_safe_params emit only what was passed IN, not values
+          # computed during the call (those belong in result_data).
+          input_keys = ctx.to_h.keys
+
           # -- Flow tracing --
           # Each operation gets its own reference_id. The root_reference_id is
           # shared across the entire execution tree via ctx (set once, inherited).
@@ -127,6 +190,14 @@ module Easyop
           parent_operation_name = ctx[:__recording_parent_operation_name]
           parent_reference_id   = ctx[:__recording_parent_reference_id]
 
+          # Execution index: 1-based position among siblings (nil for root operations).
+          # Counts are tracked per-parent in a hash stored in ctx so sibling chains
+          # and nested sub-trees each maintain independent counters.
+          execution_index = if parent_reference_id
+            counts = ctx[:__recording_child_counts] ||= {}
+            counts[parent_reference_id] = (counts[parent_reference_id] || 0) + 1
+          end
+
           # Set THIS operation as the parent for any children that run inside super.
           # Save the previous values so we can restore them after (for siblings).
           prev_parent_name = parent_operation_name
@@ -151,7 +222,9 @@ module Easyop
               root_reference_id:     root_reference_id,
               reference_id:          reference_id,
               parent_operation_name: parent_operation_name,
-              parent_reference_id:   parent_reference_id)
+              parent_reference_id:   parent_reference_id,
+              execution_index:       execution_index,
+              input_keys:            input_keys)
           end
         end
 
@@ -159,7 +232,8 @@ module Easyop
 
         def _recording_persist!(ctx, model, duration_ms,
                                 root_reference_id: nil, reference_id: nil,
-                                parent_operation_name: nil, parent_reference_id: nil)
+                                parent_operation_name: nil, parent_reference_id: nil,
+                                execution_index: nil, input_keys: nil)
           attrs = {
             operation_name:        self.class.name,
             success:               ctx.success?,
@@ -169,9 +243,11 @@ module Easyop
             root_reference_id:     root_reference_id,
             reference_id:          reference_id,
             parent_operation_name: parent_operation_name,
-            parent_reference_id:   parent_reference_id
+            parent_reference_id:   parent_reference_id,
+            execution_index:       execution_index
           }
-          attrs[:params_data] = _recording_safe_params(ctx) if self.class._recording_record_params?
+          params_config = self.class._recording_record_params_config
+          attrs[:params_data] = _recording_safe_params(ctx, params_config, input_keys) unless params_config == false
           attrs[:result_data] = _recording_safe_result(ctx) if self.class._recording_record_result_config
 
           # Only write columns the model actually has
@@ -181,37 +257,93 @@ module Easyop
           _recording_warn(e)
         end
 
-        def _recording_safe_params(ctx)
-          ctx.to_h
-             .except(*SCRUBBED_KEYS, *INTERNAL_CTX_KEYS)
-             .transform_values { |v| v.is_a?(ActiveRecord::Base) ? { id: v.id, class: v.class.name } : v }
-             .to_json
+        def _recording_safe_params(ctx, config, input_keys = nil)
+          raw = case config
+                when true
+                  # Restrict to keys that existed when the operation was invoked —
+                  # values computed during the call body are excluded here and
+                  # should be captured via record_result instead.
+                  # INTERNAL_CTX_KEYS are stripped from input_keys because nested
+                  # operations inherit parent tracing keys before their snapshot.
+                  base = ctx.to_h.except(*INTERNAL_CTX_KEYS)
+                  if input_keys
+                    clean = input_keys - INTERNAL_CTX_KEYS
+                    base.slice(*clean)
+                  else
+                    base
+                  end
+                when Hash
+                  keys = Array(config[:attrs])
+                  keys.each_with_object({}) { |k, h| h[k] = ctx[k] }
+                when Proc
+                  result = config.call(ctx)
+                  return nil unless result.is_a?(Hash)
+                  result
+                when Symbol
+                  result = send(config)
+                  return nil unless result.is_a?(Hash)
+                  result
+                end
+          _recording_apply_and_serialize(raw).to_json
         rescue
           nil
         end
 
+        # Returns true when +key+ matches any entry in +filter_list+.
+        # Regexp entries match against the stringified key name (case-sensitive
+        # unless the Regexp itself uses /i). Symbol/String entries match by value.
+        def _recording_filter_key?(key, extra_list)
+          return true if FILTERED_KEYS.include?(key.to_sym)
+
+          extra_list.any? do |pattern|
+            case pattern
+            when Regexp then pattern.match?(key.to_s)
+            when Symbol then pattern == key.to_sym
+            else             pattern.to_s == key.to_s
+            end
+          end
+        end
+
         def _recording_safe_result(ctx)
           config = self.class._recording_record_result_config
           return nil unless config
 
           raw = case config
+                when true
+                  ctx.to_h.except(*INTERNAL_CTX_KEYS)
                 when Hash
                   keys = Array(config[:attrs])
                   keys.each_with_object({}) { |k, h| h[k] = ctx[k] }
                 when Proc
-                  config.call(ctx)
+                  result = config.call(ctx)
+                  return nil unless result.is_a?(Hash)
+                  result
                 when Symbol
-                  send(config)
+                  result = send(config)
+                  return nil unless result.is_a?(Hash)
+                  result
                 end
 
           return nil unless raw.is_a?(Hash)
-
-          raw.transform_values { |v| v.is_a?(ActiveRecord::Base) ? { id: v.id, class: v.class.name } : v }
-             .to_json
+          _recording_apply_and_serialize(raw).to_json
         rescue
           nil
         end
 
+        # Applies FILTERED_KEYS + class/global filter lists to +hash+, replacing
+        # matched values with "[FILTERED]" and serializing ActiveRecord objects.
+        def _recording_apply_and_serialize(hash)
+          extra = Easyop.config.recording_filter_keys.to_a + self.class._recording_filter_keys
+          hash.each_with_object({}) do |(k, v), h|
+            h[k] = _recording_filter_key?(k, extra) ? '[FILTERED]' : _recording_serialize_value(v)
+          end
+        end
+
+        # Serializes a single value: AR objects become {id:, class:}, everything else passthrough.
+        def _recording_serialize_value(v)
+          v.is_a?(ActiveRecord::Base) ? { id: v.id, class: v.class.name } : v
+        end
+
         def _recording_warn(err)
           return unless defined?(Rails) && Rails.respond_to?(:logger)
           Rails.logger.warn "[EasyOp::Recording] Failed to record #{self.class.name}: #{err.message}"

data/lib/easyop/version.rb

@@ -1,3 +1,3 @@
 module Easyop
-  VERSION = "0.1.4"
+  VERSION = "0.1.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: easyop
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.7
 platform: ruby
 authors:
 - Pawel Niemczyk