redis_queued_locks 1.7.0 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd303479ce60c268e630d4ad770657cbe0223cffcb9990d31a9bb3de92d80843
-  data.tar.gz: 2a19bfed90da70fa8c49bf069a2acd110d3840eeb78f1f21767416c28e5bc6b7
+  metadata.gz: f787fbfe22ef8fe8dec78e5b17d4305621a4b9e2df7d3582648959e68dabef09
+  data.tar.gz: 8d874d80738959f41985e6e52d6668aa63d8232ca4964006be82f5d67ea7e1a6
 SHA512:
-  metadata.gz: 0c2d6c956bfc7227cd45c33c8b983ae759e13bf7149121c272821922d66a4be73b57b344e2042f86d0391acbe92de794013e0a67ce6157b402c6a0ca0a3a1740
-  data.tar.gz: e00ec46afd8e5d8ebef469c0a5d86a026562f8060e8abc95c4f3e89aa9351dc8961fe2d9d181aa4e8203056c74fb4aa8c4043f925b93a5b477c44541eec5ad9f
+  metadata.gz: eb726c270398079b142d68e3e45dd93226e1f17b52f370107db2f4cc47bfa6b0ce010f55dec029443bfb932d73f905f61040087577f47dca9cef5ad505fca430
+  data.tar.gz: 129089ba8f764ecabae8d0598af0f627a1156bb8b1a3e845697f1f32863d7ccd3eb2cd64cb80406408e8518b9809b35cce36e1253598744d52529d32cb092598

data/.ruby-version

@@ -1 +1 @@
-3.1.2
+3.3.3

data/CHANGELOG.md

@@ -1,8 +1,67 @@
 ## [Unreleased]
 
+## [1.9.0] - 2024-07-15
+### Added
+- Brand New Extremely Major Feature: **Swarm Mode** - eliminate zombie locks with a swarm:
+  - works by `supervisor` + `actor model` abstractions;
+  - all your ruby workers can become an element of the processs swarm;
+  - each ruby worker of the swarm probes himself that he is alive;
+  - worker that does not probes himselfs treats as a zombie;
+  - worekr becomes dead when your ruby process is dead, or thread is dead or your ractor is dead;
+  - each zombie's lock, acquier and position in queue are flushed in background via `flush_zombies` swarm element;
+  - the supervisor module keeps up and running each swarm melement (`probe_hosts` and `flush_zombies`):
+    - cuz each element works in background and can fail by any unexpected exception the supervisor guarantees that your elements will ressurect after that;
+  - each element can be deeply configured (and enabled/disabled);
+  - abilities:
+    - configurable swarming and deswarming (`#swarmize!`, `#deswarmize!`);
+    - encapsulated swarm interface;
+    - two fully isolated swarm elements: `probe_hosts` and `flush_zombies`;
+    - supervisor that keeps all elements running and wokring;
+    - an ability to check the swarm status (`#swarm_status`): who is working, who is dead, running status, internal main loop states, etc;
+    - an abiltiy to check the swarm information (`#swarm_info`): showing the current swarm hosts and their last probes and current zombie status;
+    - an ability to find zombie locks, zombie acquiers and zombie hosts (`#zombie_locks`, `#zombie_acquiers`, `#zombie_hosts`);
+    - an ability to extract the full zombie information (`#zombies_info`/`#zombies`);
+    - each zombie lock will be flushed in background by appropriated swarm element (`flush_zombies`);
+    - deeply configurable zombie factors: zombie ttl, host probing period, supervisor check period;
+    - an ability to manually probe hosts;
+    - an ability to flush zombies manually;
+    - you can made `swarm`-based logic by yourself (by manually runnable `#flush_zombies` and `#probe_hosts`);
+  - summarized interface:
+    - `#swarmize!`, `#deswarmize!`;
+    - `#swarm_status`/`#swarm_state`, `#swarm_info`
+    - `#zombie_locks`, `#zmobie_acquiers`, `#zombie_hosts`, `#zombies_info`/`#zombies`;
+    - manual abilities: `#probe_hosts`, `#flush_zombies`;
+  - **general note**: each swarm element should have their own `RedisClient` instance so each have their own redis-client configuration
+    and each of the can be configured separately (**RedisClient** multithreading limitation and **Ractor** limitations);
+- Added the `lock host` abstraction (`hst_id`):
+  - each lock is hosted by some ruby workers so this fact is abstracted into the host identifier represended as a combination of `process_id`/`thread_id`/`ractor_id`/`uniq_identity`;
+  - the ruby worker is a combination of `process_id`/`thread_id`/`ractor_id`/`uniq_identity`);
+  - each lock stores the host id (`hst_id` field) indisde their data (for debugging purposes and zombie identification purposes);
+  - every lock information method now includes `hst_id` field: `#lock_info`, `#lock_data`, `#locks_info`;
+  - an ability to fetch the current host id (your ruby worker host id): `#current_host_id`;
+  - an ability to fetch all possible host ids in the current Ractor (all possible and reachable ruby workers from the current ractor): `#possible_host_ids`;
+  - extended `RedisQueuedLocks::TimedLocktimeoutError` message: added `hst_id` field data from the lock data;
+- **Instrumentation** updates:
+  - added the `hst_id` field to each locking-process-related instrumentation event;
+- **Logging** updates:
+  - added `hst_id` field to each locking-process-related log;
+- **Logging/Instrumentation Sampling** updates:
+  - an ability to mark any loggable/instrumentable method as sampled for instrumentation/logging despite of the enabled instrumentation/log sampling
+    by providing the `log_sample_this: true` attribute and `instr_sample_this: true` attribute respectively;
+- an alias for `#clear_locks`: `#release_locks`;
+- an alias for `#unlock`: `#release_lock`;
+
+## [1.8.0] - 2024-06-13
+### Added
+- A configurable option that enables the adding additional lock/queue data to "Acquirement Timeout"-related error messages for better debugging;
+  - Configurable option is used beacuse of the extra error data requires some additional Redis requests that can be costly for memory/cpu/etc resources;
+- An ability to get the current acquirer id (`RedisQueuedLocks::Client#current_acquirer_id`);
+### Changed
+- Added additional lock information to some exceptions that does not require extra Redis requests;
+
 ## [1.7.0] - 2024-06-12
 ### Added
-- New feature: **Lock Access Strategy**: you can obtain a lock in different ways: `queued` (classic queued FIFO), `random` (get the lock immideatly if lock is free), and soon: `lifo` and `barrier`;
+- New feature: **Lock Access Strategy**: you can obtain a lock in different ways: `queued` (classic queued FIFO), `random` (get the lock immideatly if lock is free):
   - `:queued` is used by default (classic `redis_queued_locks` behavior);
   - `:random`: obtain a lock without checking the positions in the queue => if lock is free to obtain - it will be obtained;
 ### Changed