rollout 2.6.2 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: fbabd7f8b0651b97e5ebe8a2bdc4b990c810e162
-  data.tar.gz: 4b5f9ff84fbcbbbef81e05c885b67cf699309e47
+SHA256:
+  metadata.gz: cadea20a7d731c5538e5d6b6b19b34075843230fd5c6d75ffc4c269ce667a63f
+  data.tar.gz: '06483d373ff87c4e0537ab73d57be5bba089d43a4abacd87168bdf338cb4ca5e'
 SHA512:
-  metadata.gz: 1a87eb9c45aef7a24868361e04f5bdb53fb55ab2949fb411a3f39198ddac4085b63d05a730f06820feaed797327772f4bf95fc783f8f5d5c55dcf24379c51d99
-  data.tar.gz: 7c7e3b692bf11cbcebd99ad2a8d3e4db41a2b233ac5ce5ae0551c15f522e93d0f474e3fc5f868b3fedd76d1d8fb8751d178ac39ef3721b10e9a99b2499e3ec32
+  metadata.gz: 515d4d646e3c4c2c2fee20d77088a9dd22fe5730dd605764abfbc0e189591f7eaaf076830940358500e05eed30f456b9389f8843bad1df283d01b795eae6e935
+  data.tar.gz: c41503b0e1acff3c3c99de9b08d7c06167f2d4a2f7c7fc493230c11c70f633dcae0bc4c5a7028d04e11b01dfd7edfb6eaaf6d33255c559cd4b93fda206e10427

data/.github/workflows/release.yml

@@ -3,44 +3,70 @@ name: Release
 on:
   push:
     tags:
-      - 'v*'
+      - 'rollout/v*'
+      - 'rollout-redis-adapter/v*'
+      - 'rollout-active_record-adapter/v*'
+
+permissions:
+  contents: write
+  id-token: write
 
 jobs:
-  release:
+  publish:
     runs-on: ubuntu-latest
-    services:
-      redis:
-        image: redis:7-alpine
-        ports:
-          - 6379:6379
-        options: >-
-          --health-cmd "redis-cli ping"
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
+    outputs:
+      name: ${{ steps.package.outputs.name }}
+      version: ${{ steps.package.outputs.version }}
+      previous_tag: ${{ steps.package.outputs.previous_tag }}
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
         with:
-          bundler-cache: true
-      - name: Run tests
-        run: bundle exec rspec 
+          ruby-version: '3.3'
+      - name: Select package
+        id: package
+        run: |
+          case "$GITHUB_REF_NAME" in
+            rollout/v*) name=rollout; directory=. ;;
+            rollout-redis-adapter/v*) name=rollout-redis-adapter; directory=rollout-redis-adapter ;;
+            rollout-active_record-adapter/v*) name=rollout-active_record-adapter; directory=rollout-active_record-adapter ;;
+            *) echo "Unexpected tag $GITHUB_REF_NAME" >&2; exit 1 ;;
+          esac
+          version="${GITHUB_REF_NAME##*/v}"
+          spec_version=$(ruby -e 'puts Gem::Specification.load(ARGV[0]).version' "$directory/$name.gemspec")
+          if [ "$spec_version" != "$version" ]; then
+            echo "Tag version $version does not match gemspec $spec_version" >&2
+            exit 1
+          fi
+          previous_tag=$(git tag --list "$name/v*" --sort=-version:refname | awk -v current="$GITHUB_REF_NAME" '$0 != current { print; exit }')
+          previous_tag=${previous_tag:-v2.6.2}
+          echo "name=$name" >> "$GITHUB_OUTPUT"
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+          echo "directory=$directory" >> "$GITHUB_OUTPUT"
+          echo "previous_tag=$previous_tag" >> "$GITHUB_OUTPUT"
+      - name: Build selected gem
+        working-directory: ${{ steps.package.outputs.directory }}
+        run: gem build "${{ steps.package.outputs.name }}.gemspec"
+      - name: Configure RubyGems credentials
+        uses: rubygems/configure-rubygems-credentials@v2.1.0
+      - name: Publish selected gem
+        working-directory: ${{ steps.package.outputs.directory }}
+        run: gem push "${{ steps.package.outputs.name }}-${{ steps.package.outputs.version }}.gem"
+
+  github-release:
+    needs: publish
+    runs-on: ubuntu-latest
+    steps:
       - name: Create GitHub Release
-        uses: softprops/action-gh-release@v2
+        uses: softprops/action-gh-release@v3
         with:
           tag_name: ${{ github.ref }}
-          name: ${{ github.ref_name }}
+          name: ${{ needs.publish.outputs.name }} ${{ needs.publish.outputs.version }}
           generate_release_notes: true
+          previous_tag: ${{ needs.publish.outputs.previous_tag }}
           draft: false
-          prerelease: false 
-      - name: Set up RubyGems credentials
-        env:
-          RUBYGEMS_API_KEY: ${{ secrets.RUBYGEMS_API_KEY }}
-        run: |
-          mkdir -p ~/.gem
-          echo ":rubygems_api_key: $RUBYGEMS_API_KEY" > ~/.gem/credentials
-          chmod 0600 ~/.gem/credentials
-      - name: Release to RubyGems
-        run: bundle exec rake release
+          prerelease: false

data/.github/workflows/test.yml

@@ -4,13 +4,115 @@ on:
   push:
     branches:
       - master
+      - v3
   pull_request:
-    branches:
-      - master
+
 
 jobs:
-  test:
+  core:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['3.3', '3.2', '3.1', '3.0', '2.7', '2.6', '2.5', '2.4']
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+      - name: Run core tests
+        run: |
+          mkdir -p test_results
+          bundle exec rspec spec --format progress --format RspecJunitFormatter --out test_results/rspec.xml
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v6
+        with:
+          name: core-test-results-${{ matrix.ruby-version }}
+          path: test_results/rspec.xml
+          retention-days: 30
+
+  redis:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['3.3', '3.2', '3.1', '3.0', '2.7', '2.6', '2.5', '2.4']
+    services:
+      redis:
+        image: redis:7-alpine
+        ports:
+          - 6379:6379
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          working-directory: rollout-redis-adapter
+          bundler-cache: true
+      - name: Run Redis adapter tests
+        working-directory: rollout-redis-adapter
+        run: |
+          mkdir -p test_results
+          bundle exec rspec --format progress --format RspecJunitFormatter --out test_results/rspec.xml
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v6
+        with:
+          name: redis-test-results-${{ matrix.ruby-version }}
+          path: rollout-redis-adapter/test_results/rspec.xml
+          retention-days: 30
+
+  active_record:
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - ruby-version: '3.3'
+            activerecord: '~> 8.1.0'
+            db: sqlite3
+          - ruby-version: '3.3'
+            activerecord: '~> 8.1.0'
+            db: postgresql
+          - ruby-version: '3.3'
+            activerecord: '~> 8.1.0'
+            db: mysql2
+          - ruby-version: '3.3'
+            activerecord: '~> 7.1.0'
+            db: postgresql
+          - ruby-version: '3.3'
+            activerecord: '~> 7.1.0'
+            db: mysql2
+          - ruby-version: '3.2'
+            activerecord: '~> 8.0.0'
+            db: sqlite3
+          - ruby-version: '3.1'
+            activerecord: '~> 7.2.0'
+            db: sqlite3
+          - ruby-version: '2.7'
+            activerecord: '~> 7.1.0'
+            db: sqlite3
+    env:
+      ACTIVERECORD_VERSION: ${{ matrix.activerecord }}
+      ROLLOUT_AR_ADAPTER: ${{ matrix.db }}
+      POSTGRES_HOST: localhost
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: rollout_test
+      MYSQL_HOST: 127.0.0.1
+      MYSQL_USER: root
+      MYSQL_PASSWORD: root
+      MYSQL_DATABASE: rollout_test
+      REDIS_HOST: 127.0.0.1
     services:
       redis:
         image: redis:7-alpine
@@ -21,12 +123,52 @@ jobs:
           --health-interval 10s
           --health-timeout 5s
           --health-retries 5
+      postgres:
+        image: postgres:16
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: rollout_test
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd "pg_isready -U postgres"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+      mysql:
+        image: mysql:8.0
+        env:
+          MYSQL_ROOT_PASSWORD: root
+          MYSQL_DATABASE: rollout_test
+        ports:
+          - 3306:3306
+        options: >-
+          --health-cmd "mysqladmin ping -h 127.0.0.1 -uroot -proot"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
+      - name: Install database client libraries
+        run: sudo apt-get update && sudo apt-get install -y libpq-dev default-libmysqlclient-dev
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
         with:
+          ruby-version: ${{ matrix.ruby-version }}
+          working-directory: rollout-active_record-adapter
           bundler-cache: true
-      - name: Run tests
-        run: bundle exec rspec 
+          cache-version: ar-${{ matrix.ruby-version }}-${{ matrix.activerecord }}-${{ matrix.db }}
+      - name: Run Active Record adapter tests
+        working-directory: rollout-active_record-adapter
+        run: |
+          mkdir -p test_results
+          bundle exec rspec --format progress --format RspecJunitFormatter --out test_results/rspec.xml
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v5
+        with:
+          name: active-record-test-results-${{ matrix.ruby-version }}-${{ matrix.db }}-${{ strategy.job-index }}
+          path: rollout-active_record-adapter/test_results/rspec.xml
+          retention-days: 30

data/.gitignore

@@ -18,7 +18,9 @@ coverage
 rdoc
 pkg
 *.gem
+Gemfile.lock
 gemfiles/*.lock
+test_results
 .rspec_status
 .bundle/config
 /vendor

data/README.md

@@ -1,34 +1,43 @@
 # rollout
 
-Fast feature flags based on Redis.
+Fast feature flags.
+
+Upgrading from Rollout 2? Follow the [Rollout 3 upgrade guide](docs/upgrading-to-v3.md)
+before updating your dependencies.
 
 [![Gem Version](https://badge.fury.io/rb/rollout.svg)](https://badge.fury.io/rb/rollout)
-[![CircleCI](https://circleci.com/gh/fetlife/rollout.svg?style=svg)](https://circleci.com/gh/fetlife/rollout)
+[![CI](https://github.com/fetlife/rollout/actions/workflows/test.yml/badge.svg)](https://github.com/fetlife/rollout/actions/workflows/test.yml)
 [![Code Climate](https://codeclimate.com/github/FetLife/rollout/badges/gpa.svg)](https://codeclimate.com/github/FetLife/rollout)
 [![Test Coverage](https://codeclimate.com/github/FetLife/rollout/badges/coverage.svg)](https://codeclimate.com/github/FetLife/rollout/coverage)
 
 ## Install it
 
 ```bash
-gem install rollout
+gem install rollout -v '~> 3.1'
+gem install rollout-redis-adapter -v '~> 0.1'
 ```
 
+```ruby
+gem "rollout", "~> 3.1"
+gem "rollout-redis-adapter", "~> 0.1"
+```
+
+Active Record applications can use `rollout-active_record-adapter` instead of
+`rollout-redis-adapter`. See the [Active Record adapter README](rollout-active_record-adapter/README.md).
+To copy current feature state from Redis, see
+[Migrate from Redis](rollout-active_record-adapter/README.md#migrate-from-redis).
+
 ## How it works
 
 Initialize a rollout object. I assign it to a global var.
 
 ```ruby
-require 'redis'
+require "redis"
+require "rollout"
+require "rollout-redis-adapter"
 
 $redis = Redis.new
-$rollout = Rollout.new($redis)
-```
-
-or even simpler
-
-```ruby
-require 'redis'
-$rollout = Rollout.new($redis) # Will use REDIS_URL env var or default redis url
+$rollout = Rollout.new(adapter: Rollout::Adapters::Redis.new($redis))
 ```
 
 
@@ -109,11 +118,12 @@ $rollout.activate_percentage(:chat, 20)
 The algorithm for determining which users get let in is this:
 
 ```ruby
-CRC32(user.id) < (2**32 - 1) / 100.0 * percentage
+Zlib.crc32(user.id.to_s) < (2**32 - 1) / 100.0 * percentage
 ```
 
-So, for 20%, users 0, 1, 10, 11, 20, 21, etc would be allowed in. Those users
-would remain in as the percentage increases.
+The result is deterministic: the same user is always in or out at a given
+percentage, and users already included remain included as the percentage
+increases.
 
 Deactivate all percentages like this:
 
@@ -128,7 +138,10 @@ In some cases you might want to have a feature activated for a random set of
 users. It can come specially handy when using Rollout for split tests.
 
 ```ruby
-$rollout = Rollout.new($redis, randomize_percentage: true)
+$rollout = Rollout.new(
+  adapter: Rollout::Adapters::Redis.new($redis),
+  randomize_percentage: true,
+)
 ```
 
 When on `randomize_percentage` will make sure that 50% of users for feature A
@@ -166,8 +179,9 @@ failure detection code.
 You can inspect the state of your feature using:
 
 ```ruby
->> $rollout.get(:chat)
-=> #<Rollout::Feature:0x00007f99fa4ec528 @data={}, @groups=[:caretakers], @name=:chat, @options={}, @percentage=0.05, @users=["1"]>
+feature = $rollout.get(:chat)
+feature.to_hash
+# => { percentage: 5.0, groups: [:caretakers], users: ["1"], data: {} }
 ```
 
 ## Namespacing
@@ -180,18 +194,32 @@ environments by using the
 [redis-namespace](https://github.com/resque/redis-namespace) gem.
 
 ```ruby
+gem "redis-namespace"
+```
+
+```ruby
+require "redis"
+require "redis/namespace"
+require "rollout"
+require "rollout-redis-adapter"
+
 $ns = Redis::Namespace.new(Rails.env, redis: $redis)
-$rollout = Rollout.new($ns)
+$rollout = Rollout.new(adapter: Rollout::Adapters::Redis.new($ns))
 $rollout.activate_group(:chat, :all)
 ```
 
-This example would use the "development:feature:chat:groups" key.
+This example stores the chat feature at `development:feature:chat` when
+`Rails.env` is `"development"`.
 
 ## Frontend / UI
 
 * [rollout-ui](https://github.com/fetlife/rollout-ui)
 * [Rollout-Dashboard](https://github.com/fiverr/rollout_dashboard/)
 
+These integrations may not yet support Rollout 3. Use a version compatible with
+the Rollout release you install. If you depend on rollout-ui, wait for a
+Rollout 3-compatible UI release before upgrading production.
+
 ## Implementations in other languages
 
 *   Python: https://github.com/asenchi/proclaim
@@ -207,13 +235,65 @@ This example would use the "development:feature:chat:groups" key.
 *   Eric Rafaloff - Maintainer - https://github.com/EricR
 
 
-## Releasing
+## Testing
+
+Install dependencies first. Core and the adapter gems have separate Gemfiles:
+
+```bash
+bundle install
+bundle install --gemfile=rollout-redis-adapter/Gemfile
+bundle install --gemfile=rollout-active_record-adapter/Gemfile
+```
 
-1. Bump version: `rake version:patch` (or `minor`/`major`)
-2. Commit and tag: `git commit -am "Bump version" && git tag v0.7.3`
-3. Push: `git push origin master --tags`
+Core tests do not need Redis:
+
+```bash
+bundle exec rake spec
+```
+
+Redis adapter tests flush database 7 by default. Use a disposable instance,
+not a shared or production Redis. Start Redis in a separate terminal:
+
+```bash
+docker run --rm -p 6379:6379 redis:7-alpine
+```
+
+Then run:
+
+```bash
+bundle exec rake spec:redis
+```
+
+Optional connection settings: `REDIS_HOST`, `REDIS_PORT`, `REDIS_DB`. `REDIS_DB`
+overrides the default database 7 that is flushed before each example.
+
+Active Record adapter tests default to SQLite. PostgreSQL and MySQL are also
+supported:
+
+```bash
+bundle exec rake spec:active_record
+ROLLOUT_AR_ADAPTER=postgresql bundle exec rake spec:active_record
+ROLLOUT_AR_ADAPTER=mysql2 bundle exec rake spec:active_record
+```
+
+## Releasing
 
-The GitHub Actions workflow will automatically publish to RubyGems when tags are pushed.
+Each gem has its own version and tag.
+
+- Configure a RubyGems trusted publisher for the gem you are releasing. Use
+  repository owner `fetlife`, repository `rollout`, workflow filename
+  `release.yml`, and no GitHub environment.
+- Update and commit the version in `lib/rollout/version.rb`,
+  `rollout-redis-adapter/rollout-redis-adapter.gemspec`, or
+  `rollout-active_record-adapter/rollout-active_record-adapter.gemspec`.
+- Tag the release commit with `rollout/vX.Y.Z`,
+  `rollout-redis-adapter/vX.Y.Z`, or
+  `rollout-active_record-adapter/vX.Y.Z`, matching the gem version.
+- Push the tag with `git push origin <tag>`. CI publishes the selected gem and
+  creates its GitHub release.
+
+Use package-prefixed tags, not `vX.Y.Z`. Publish core first when the adapter
+depends on a new core version.
 
 ## Copyright
 

data/Rakefile

@@ -1,9 +1,32 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
-RSpec::Core::RakeTask.new(:spec)
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.pattern = "spec/**/*_spec.rb"
+end
+
+namespace :spec do
+  desc "Run Redis adapter tests"
+  task :redis do
+    gemfile = File.expand_path("rollout-redis-adapter/Gemfile", __dir__)
+    Dir.chdir("rollout-redis-adapter") do
+      Bundler.with_unbundled_env do
+        sh({ "BUNDLE_GEMFILE" => gemfile }, "bundle exec rspec")
+      end
+    end
+  end
+
+  desc "Run Active Record adapter tests"
+  task :active_record do
+    gemfile = File.expand_path("rollout-active_record-adapter/Gemfile", __dir__)
+    Dir.chdir("rollout-active_record-adapter") do
+      Bundler.with_unbundled_env do
+        sh({ "BUNDLE_GEMFILE" => gemfile }, "bundle exec rspec")
+      end
+    end
+  end
+end
 
 task default: :spec
 

data/docs/upgrading-to-v3.md

@@ -0,0 +1,110 @@
+# Upgrading to Rollout 3
+
+Rollout 3 keeps feature evaluation in the `rollout` gem and moves Redis
+persistence to `rollout-redis-adapter`. Existing Redis keys stay in place. This is
+not a storage migration onto Active Record. For the Active Record adapter
+and Redis cutover, see
+[rollout-active_record-adapter/README.md](../rollout-active_record-adapter/README.md).
+
+## 1. Update dependencies
+
+Add the adapter gem next to `rollout`:
+
+```ruby
+gem "rollout", "~> 3.1"
+gem "rollout-redis-adapter", "~> 0.1"
+```
+
+Use compatible releases of both gems. The Redis adapter is versioned
+independently of core. Rollout `3.0.0` used `backend:` and
+`Rollout::Redis::Backend`; `3.1.0` uses `adapter:` and
+`Rollout::Adapters::Redis`. If you use
+[rollout-ui](https://github.com/fetlife/rollout-ui), wait for a Rollout
+3-compatible UI release before upgrading production.
+
+## 2. Update requires and initialization
+
+```ruby
+# Before
+require "redis"
+require "rollout"
+
+$redis = Redis.new
+$rollout = Rollout.new(
+  $redis,
+  randomize_percentage: true,
+  logging: { history_length: 100, global: true },
+)
+```
+
+```ruby
+# After
+require "redis"
+require "rollout"
+require "rollout-redis-adapter"
+
+$redis = Redis.new
+$rollout = Rollout.new(
+  adapter: Rollout::Adapters::Redis.new($redis),
+  randomize_percentage: true,
+  logging: { history_length: 100, global: true },
+)
+```
+
+Pass the same Redis client, database, and namespace you already use. Repeat
+this change at every initialization site, including jobs, scripts, and
+consoles.
+
+`redis-namespace` still works:
+
+```ruby
+$ns = Redis::Namespace.new(Rails.env, redis: $redis)
+$rollout = Rollout.new(adapter: Rollout::Adapters::Redis.new($ns))
+```
+
+## 3. Breaking changes
+
+| Area | Breaking change | Required action |
+| --- | --- | --- |
+| Storage configuration | `Rollout.new(redis, options)` now requires `adapter:`. | Wrap the existing client in `Rollout::Adapters::Redis.new(redis)` and pass options as keywords. |
+| Storage access | `rollout.storage` is removed. `rollout.adapter` returns an adapter, not the Redis client. | Keep your own Redis client reference if application code needs direct access. |
+| Logging storage | `logging: { storage: other_redis }` is no longer supported. The Redis backend stores features and history through the same client. | Applications using separate history storage cannot preserve that setup with the current adapter. Removing the option does not migrate existing history. |
+| Custom logging | `Logger#log` and `Logger#update` are removed. Built-in logging is no longer an observer. | Use Rollout mutations and `logging.with_context` rather than calling those methods directly. |
+| Feature construction | `Feature.new(name, rollout:, state: payload)` no longer accepts a name argument or raw Redis payload. | Prefer `rollout.get(name)`. Direct construction requires `Feature.new(state: feature_state, rollout: rollout, options: rollout.options)`. |
+| Feature serialization | `feature.serialize` is removed. | Use `feature.to_feature_state` for a backend-neutral snapshot. Redis encoding belongs to `Rollout::Redis::Codec`. |
+| Feature metadata | Metadata is canonicalized to JSON. Symbol keys and values become strings. Values such as `Time`, `Date`, and `BigDecimal` persist as their JSON representations, not as original Ruby objects. | No data migration is required. JSON-serializable writes continue to work. |
+| History decoding | `Logging::Event.from_raw` is removed. | Decode persisted Redis members with `Rollout::Redis::Codec.decode_event(value, score)`. |
+
+## 4. History and lifecycle
+
+History reads can request a bound. `limit` is the newest N events, returned
+oldest-to-newest. Omit `limit` to read the full retained history. `0` returns
+no events.
+
+```ruby
+rollout.logging.events(:chat, limit: 10)
+rollout.logging.global_events(limit: 10)
+rollout.logging.last_event(:chat)
+```
+
+`last_event` reads one persisted member. It does not load the complete
+history.
+
+| Operation | Feature state | Per-feature history | Global history |
+| --- | --- | --- | --- |
+| `delete`, logging enabled | Removed | Removed | Retained; emits a global `delete` event when `global: true` and the adapter supports event-aware deletion |
+| `delete`, logging disabled | Removed | Retained | Retained |
+| `logging.delete` | Unchanged | Removed | Retained |
+| `clear!` | Removed | Retained | Retained |
+
+The deletion event includes the feature name, timestamp, and current logging
+context (for example, an actor supplied with `logging.with_context`). Built-in
+adapters write it only when the feature exists and global logging is enabled;
+it is subject to `history_length` like other global events. Older or custom
+adapters without `delete_feature_with_history` retain the previous deletion
+behavior and do not record a deletion event.
+
+`clear!` still resets each feature first, so logging-enabled instances record
+a reset event before the state is deleted. History remains subject to
+`history_length`. The Redis registry key is removed after clearing, including
+when it was already empty.