kicks_liveness 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c784de1ca564182e9e36f8fb2956bb61a854c50995bdfe656c68805df671aed
-  data.tar.gz: e40f05ab3385e7b6dd680e040888120693751bda5ff5b2ff2625e107c4ff7cf9
+  metadata.gz: df61d00933097bb96e6d752e024e349ab631cd7c9d571cd9bff9ff63b8adda40
+  data.tar.gz: 78864373ca06cd998cdee192d064cd00ed69a4ecd73eb1b657474d77ab593066
 SHA512:
-  metadata.gz: e4e1088cc18b3a51493f330e2f37b3eba223dd6b21be77adcaf50833362a29b805d35f7d851ad31a2f84f2d7a9e5b69792cf443fd5cac2e8b2a44e53d70b9f29
-  data.tar.gz: 99345f3a010f4f6c72936e80a81fdff2a6ebf0ea371596bc90850b47cfe5abacaa93694b629fd9121de386e04a5272d44b46b3425f88229ae66c2e3fc0c555f7
+  metadata.gz: '007091e18fea1b216ba25c634bab1a4770d25cc0f062ee30ba2885563075bc94e7662e58eebbac9507b448217508725612f172189b692e3a4d616e5f81fdd46b'
+  data.tar.gz: f460271ca68fdf912559b3fa2c41b02074d5eb457e946d2f985e3e2b0ac3da66dc94ce90c9d5639212a0fc7bb6537046654f31921cf6766fe15c903bd7dc04ef

data/CHANGELOG.md

@@ -5,6 +5,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.1.2] - 2026-09-11
+
+### Fixed
+
+- Reject heartbeat files inherited from a previous container incarnation. A
+  Kubernetes `emptyDir` survives container restarts, so a fresh mark left by a
+  formerly healthy worker could make the next container pass `startupProbe`
+  before its consumers had subscribed. Cache files elsewhere in the same
+  `emptyDir` remain untouched and available to warm the next application boot.
+  This protection assumes the default container-private PID namespace; pods
+  using `shareProcessNamespace` or `hostPID` retain the 0.1.1 freshness-only
+  behavior (see `docs/LIMITATIONS.md`).
+  The marks directory now contains `<dir>/generation`, and each
+  `worker-<slot>` mark carries the same value; tooling that enumerates the
+  directory should allow for this new metadata file.
+
 ## [0.1.1] - 2026-09-09
 
 ### Added
@@ -57,6 +73,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
   [docs/](https://github.com/PoroshkinaVV/kicks_liveness/tree/main/docs); start
   with `SETUP.md`, and read `LIMITATIONS.md` before relying on it.
 
-[Unreleased]: https://github.com/PoroshkinaVV/kicks_liveness/compare/v0.1.1...HEAD
+[Unreleased]: https://github.com/PoroshkinaVV/kicks_liveness/compare/v0.1.2...HEAD
+[0.1.2]: https://github.com/PoroshkinaVV/kicks_liveness/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/PoroshkinaVV/kicks_liveness/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/PoroshkinaVV/kicks_liveness/releases/tag/v0.1.0

data/README.md

@@ -10,8 +10,14 @@
 Rails or querying RabbitMQ from the probe.**
 
 The worker checks its own Bunny consumers and publishes a heartbeat to tmpfs.
-The probe only reads that heartbeat. No application boot, no network call, and
-no healthy replica hiding a stalled one.
+The probe only reads that heartbeat, scoped to the current container
+incarnation. No application boot, no network call, and no healthy replica
+hiding a stalled one.
+
+That restart scoping assumes Kubernetes' default container-private PID
+namespace; see
+[Limitations](docs/LIMITATIONS.md#container-generations-require-linux-procfs-and-container-owned-pid-1)
+for pods that set `shareProcessNamespace` or `hostPID`.
 
 ## Install: one line in Rails
 
@@ -189,7 +195,7 @@ negative path before rollout; the commands and expected output are in
 | [Design](docs/DESIGN.md) | health predicate, heartbeat files, hooks, configuration choices, and measurements |
 | [Running under Kubernetes](docs/KUBERNETES.md) | full manifest, CPU/startup budgets, alerts, and live-pod verification |
 | [Limitations](docs/LIMITATIONS.md) | cases the in-memory predicate intentionally cannot cover |
-| [Verification scenarios](docs/VERIFYING.md) | ten deliberately induced failures and their observed outcomes |
+| [Verification scenarios](docs/VERIFYING.md) | eleven deliberately induced failures and their observed outcomes |
 
 ## Contributing
 

data/docs/DESIGN.md

@@ -40,16 +40,17 @@ outside it can, so let the worker publish and let the probe read.
 
 Every `tick` seconds (10 by default) the worker checks, **in its own memory**,
 that its consumers are still subscribed, and touches a file on tmpfs. The probe
-loads one dependency-free Ruby file, reads the file's mtime, and exits with 0 or
-1.
+loads one dependency-free Ruby file, checks the marks' container generation and
+mtimes, and exits with 0 or 1.
 
 The probe therefore performs no network I/O and boots no framework, and the
-state it reads — the mark's mtime — comes from tmpfs, which is RAM. Be precise
-about the disk, though: starting the probe still loads the Ruby interpreter and
-two files of this gem from the image filesystem, and those reads are ordinary
-filesystem reads (usually served from page cache, but not guaranteed to be). The
-honest claim is not "no disk" but *no application boot, and no disk on the path
-that decides the answer* — which is what removes the defects above, not tuning.
+state it reads — the generation and mark mtimes — comes from procfs and tmpfs.
+Be precise about the disk, though: starting the probe still loads the Ruby
+interpreter and two files of this gem from the image filesystem, and those reads
+are ordinary filesystem reads (usually served from page cache, but not
+guaranteed to be). The honest claim is not "no disk" but *no application boot,
+and no disk on the path that decides the answer* — which is what removes the
+defects above, not tuning.
 
 ## The health predicate
 
@@ -112,6 +113,7 @@ silently. That is the thing to re-check when upgrading Bunny.
 
 ```
 <dir>/expected       how many forks the probe must wait for
+<dir>/generation     which container incarnation wrote this heartbeat
 <dir>/worker-<slot>  one per fork, refreshed every tick the fork is healthy
 <dir>/attempt-<slot> starts of a slot that has not become healthy yet
 ```
@@ -127,6 +129,24 @@ it: if the directory is wiped, `touch!` brings the slot marks back while
 rest of the pod's life. Rewriting it is also what lets a respawned set of forks
 correct a count that has been lowered.
 
+**`generation` closes a container-restart hole when the container owns PID 1.**
+Kubernetes preserves an `emptyDir` when it restarts a container inside the same
+pod. That is useful for an application cache elsewhere in the volume, but a
+fresh heartbeat from the dead process must not let the new container pass its
+one-shot `startupProbe`. On Linux, the worker and exec probe independently
+derive the same incarnation from the container's mount namespace and PID 1
+start time. Both `generation` and every slot mark carry it. Until the new
+container declares itself and every current fork publishes its own mark, files
+inherited from the previous container are rejected. Nothing outside the marks
+directory is removed.
+
+This guarantee assumes Kubernetes' default container-private PID namespace.
+With `shareProcessNamespace: true` PID 1 belongs to the pod sandbox, and with
+`hostPID: true` it is the node init process; neither restarts with the worker
+container. Under either setting the guard can accept an inherited fresh mark.
+Do not enable them on a pod whose startup probe relies on this guarantee; see
+[LIMITATIONS.md](LIMITATIONS.md#container-generations-require-linux-procfs-and-container-owned-pid-1).
+
 **Files are named by supervisor slot, not by PID.** A fork killed with SIGKILL
 is respawned into the same slot and overwrites its own file. Had the name
 contained a PID, that file would sit there stale forever and the probe would
@@ -143,12 +163,13 @@ probe sees either the old value or the new one.
 the single reason that the directory outlives the fork: a monitor caught in a
 respawn loop is a brand-new object every few hundred milliseconds and can hold
 no counter of its own. The file is removed once the slot becomes healthy, so in
-steady state the directory holds only `expected` and the `worker-<slot>` marks;
-what the counter is for is in
+steady state the directory holds `expected`, `generation`, and the
+`worker-<slot>` marks. What the counter is for is in
 [LIMITATIONS.md](LIMITATIONS.md#a-respawn-loop-is-reported-once-per-grace-window-not-once-per-respawn).
 
-The *contents* of `worker-<slot>` (timestamp, pid, slot) exist only for a human
-running `kubectl exec ... cat`. The probe decides on mtime alone.
+The timestamp, pid, and slot in `worker-<slot>` exist for a human running
+`kubectl exec ... cat`. Its generation is part of the probe contract; freshness
+still comes from mtime.
 
 The directory must be on tmpfs — in Kubernetes, an `emptyDir` with
 `medium: Memory`. Put it on a real disk and the probe starts depending on the

data/docs/KUBERNETES.md

@@ -46,6 +46,21 @@ Without `medium: Memory` an `emptyDir` is backed by the node's disk, and the
 probe starts depending on the disk again — which is one of the things it exists
 to avoid.
 
+An `emptyDir` deliberately survives a restart of the container inside its pod.
+That keeps a Bootsnap or other application cache under `/opt/app/tmp` warm for
+the next attempt, but it also leaves the previous process's heartbeat files in
+`health/`. The gem does not clear the volume or that directory. Instead it
+records the current Linux container generation separately and in every slot
+mark. A fresh mark from the previous container is rejected until every fork in
+the current one has subscribed and published its own mark, so preserving the
+cache cannot make `startupProbe` succeed early.
+
+That guarantee assumes the default container-private PID namespace. Do not set
+`shareProcessNamespace: true` or `hostPID: true` on a pod that relies on it: in
+either topology PID 1 survives a worker-container restart, and the generation
+guard can accept an inherited fresh mark. See
+[LIMITATIONS.md](LIMITATIONS.md#container-generations-require-linux-procfs-and-container-owned-pid-1).
+
 ## Why the command looks like that
 
 **`bundle exec kicks-liveness` is the standard command.** It works regardless
@@ -104,6 +119,12 @@ executable is found regardless of `BUNDLE_PATH`, which is why it is the standard
 command. Run bare, it depends on the gem's `bin` directory being on `PATH`,
 which is not something to rely on in a manifest.
 
+Keep the worker and probe on the same gem version. Since 0.1.2 the heartbeat
+protocol includes a container generation; a newer probe correctly rejects the
+generation-less files written by an older worker. `bundle exec` guarantees that
+both sides resolve from the same bundle. If the faster form below installs a
+second copy in `GEM_HOME`, rebuild that copy on every gem upgrade too.
+
 ### Where your image puts its gems
 
 Before replacing the standard command with plain Ruby, run this against your

data/docs/LIMITATIONS.md

@@ -92,6 +92,37 @@ count and the retired slots eventually go stale. Neither direction is safe.
 
 If you change `workers`, restart the runner. Runtime scaling is not supported.
 
+## Container generations require Linux procfs and container-owned PID 1
+
+Kubernetes keeps an `emptyDir` across restarts of a container in the same pod.
+To prevent the next container from inheriting a fresh heartbeat, the worker and
+exec probe independently identify their shared incarnation from Linux procfs:
+the mount namespace plus PID 1 start time. No application cache is removed.
+
+The identifier also assumes that the container owns PID 1. With
+`shareProcessNamespace: true`, PID 1 is the pod sandbox, and with
+`hostPID: true` it is the node's init process; neither restarts when the worker
+container does, so the start-time half of the identifier stays constant. The
+mount namespace inode is then the only remaining signal, and the kernel
+normally hands the just-released inode back to the replacement container in an
+otherwise quiet pod. Under either setting the guard silently degrades to the
+0.1.1 freshness-only behavior and can accept a fresh mark from the previous
+container. Do not enable either setting on a pod whose `startupProbe` relies on
+this guarantee.
+
+If procfs is unavailable — for example, when using the gem outside a Linux
+container — generation detection falls back to the original freshness-only
+check. The worker and probe still function, but they cannot distinguish a fresh
+mark left by a previous process from one written by the current process. Linux
+Kubernetes, Docker, and Nomad containers expose the required procfs entries
+under their normal configuration.
+
+The worker and its exec probe must run in the **same container**. A neighbouring
+sidecar can mount the same `emptyDir`, but it has a different mount namespace
+and therefore treats the worker's marks as belonging to another container.
+Kubernetes exec probes already run inside the container they check; do not move
+`kicks-liveness` into a separate health sidecar.
+
 ## A respawn loop is reported once per grace window, not once per respawn
 
 When a fork cannot subscribe at all, the supervisor brings it back after
@@ -112,6 +143,15 @@ reports the elapsed time and the number of starts:
 The number of starts is the diagnosis: it separates a slow start from a respawn
 loop at a glance.
 
+This unhealthy-run counter is scoped to the marks volume, not to the container
+generation. If a container is restarted before its slot has ever become
+healthy, the replacement continues the same count: its repeated `started:` line
+is suppressed, and an expired grace window may immediately report an ERROR that
+includes starts from the previous container. This is diagnostic state only; it
+does not participate in the probe result, and the first healthy tick removes
+it. Treat the count as "starts since this slot was last healthy in this pod",
+not "starts in this container".
+
 ## Do not install both `kicks` and `sneakers`
 
 The gem declares neither as a dependency, because at runtime it needs only the

data/docs/SETUP.md

@@ -174,11 +174,13 @@ Once workers are running, the marks directory is the other half of the answer:
 ```
 $ ls -l /opt/app/tmp/health/
 expected
+generation
 worker-0
 worker-1
 ```
 
-One `worker-<slot>` file per fork, plus `expected`. If `expected` is there and
-the slot files are not, the workers have not finished subscribing. A slot that
-keeps restarting without ever subscribing also leaves an `attempt-<slot>` file,
-which is removed as soon as that slot becomes healthy.
+One `worker-<slot>` file per fork, plus `expected` and the current container
+`generation`. If `expected` is there and the slot files are not, the workers
+have not finished subscribing. A slot that keeps restarting without ever
+subscribing also leaves an `attempt-<slot>` file, which is removed as soon as
+that slot becomes healthy.

data/docs/VERIFYING.md

@@ -97,11 +97,15 @@ spec/integration/verify.sh probe
 INFO: [liveness] slot 0: started: dir=/opt/app/tmp/health max_age=45s tick=10s processes=1 consumers=2
 INFO: [liveness] slot 0: waiting for 2 consumers
 INFO: [liveness] slot 0: healthy          # one tick later
-expected  worker-0                        # in the marks directory
+expected  generation  worker-0            # in the marks directory
 1 process(es) healthy                     # probe, exit 0
 ```
 
-The hooks fired inside a real ServerEngine fork, which no double can show.
+The hooks fired inside a real ServerEngine fork, which no double can show. On a
+fresh fixture the first attempt also prints `started:`. Do not use that line as
+the sole proof after a same-pod container restart: an inherited unhealthy-run
+counter deliberately suppresses repeated start lines, as described in
+[LIMITATIONS.md](LIMITATIONS.md#a-respawn-loop-is-reported-once-per-grace-window-not-once-per-respawn).
 
 ### 2. A stale mark
 
@@ -242,9 +246,9 @@ find them.
 ```
 INFO: [liveness] slot 0: started: ... processes=2 consumers=2
 INFO: [liveness] slot 1: started: ... processes=2 consumers=2
-expected  worker-0  worker-1      # expected contains "2"
-2 process(es) healthy             # exit 0
-worker-1 stale 120s > 45s         # exit 1 — staling either mark is enough
+expected  generation  worker-0  worker-1  # expected contains "2"
+2 process(es) healthy                     # exit 0
+worker-1 stale 120s > 45s                 # exit 1 — staling either mark is enough
 ```
 
 Both marks are required, not just the first.
@@ -331,6 +335,38 @@ pod is restarted. That is why the documented rule set pairs it with
 `absent_over_time`, and why an `up == 0` on the scrape job is worth having
 beside both.
 
+### 11. A private-PID container restart cannot inherit a healthy mark
+
+This scenario needs the fixture image but not Kubernetes or RabbitMQ. It starts
+a container that publishes a healthy mark into a named volume, restarts that
+same container, and delays the new writer for 15 seconds:
+
+```bash
+spec/integration/verify.sh build
+spec/integration/verify.sh generation-restart
+```
+
+During the delay the inherited mark is still fresh, but the probe must reject
+its old generation. Once the replacement writer publishes its own mark, the
+same probe must become healthy again. The command checks both transitions and
+prints output in this form:
+
+```
+before=mnt:[4026532686]:123456
+after=mnt:[4026532686]:123789
+inherited=heartbeat belongs to a previous container: worker has not started yet
+recovered=1 process(es) healthy
+```
+
+The namespace inode is allowed to be reused, as in the example above; the PID 1
+start time still distinguishes the two incarnations. The test removes its
+container and named volume on exit.
+
+This scenario covers the default container-private PID namespace. With
+`shareProcessNamespace: true` or `hostPID: true`, PID 1 survives the worker
+container restart and this guarantee does not hold; see
+[LIMITATIONS.md](LIMITATIONS.md#container-generations-require-linux-procfs-and-container-owned-pid-1).
+
 ## What to do with a disagreement
 
 Record it, then fix whichever is wrong — the code or the document. The numbers

data/lib/kicks_liveness/heartbeat.rb

@@ -1,5 +1,57 @@
 module KicksLiveness
-  # The liveness mark on the filesystem: written by the worker, read by the
+  # Identifies an ordinary Linux container incarnation shared by the worker and
+  # exec probes without writing anything to the marks directory. This assumes
+  # the container owns PID 1; shared and host PID namespaces are documented as
+  # unsupported in +docs/LIMITATIONS.md+.
+  # @api private
+  module ContainerGeneration
+    module_function
+
+    # @return [String, nil] current private-PID Linux container incarnation, or
+    #   nil when procfs does not expose one
+    # @api private
+    def current
+      mount_namespace = File.readlink('/proc/self/ns/mnt')
+      stat = File.read('/proc/1/stat')
+      closing_parenthesis = stat.rindex(') ')
+      return unless closing_parenthesis
+
+      # After the command in parentheses, field 3 (`state`) is index 0. Process
+      # start time is field 22, therefore index 19 in this tail.
+      started_at = stat[(closing_parenthesis + 2)..].split[19]
+      return unless started_at && Integer(started_at).positive?
+
+      "#{mount_namespace}:#{started_at}"
+    rescue StandardError
+      nil
+    end
+  end
+
+  # Generation-specific parts of the filesystem contract.
+  # @api private
+  module GenerationGuard
+    private
+
+    def generation_path
+      File.join(@dir, 'generation')
+    end
+
+    def declared_generation
+      File.read(generation_path)
+    rescue StandardError
+      nil
+    end
+
+    def current_generation?
+      !@generation || declared_generation == @generation
+    end
+
+    def previous_generation?(path)
+      @generation && File.read(path)[/\bgeneration=(\S+)/, 1] != @generation
+    end
+  end
+
+  # The liveness marks on the filesystem: written by the worker, read by the
   # probe.
   #
   # The directory must live on tmpfs — in Kubernetes, an emptyDir with
@@ -17,6 +69,8 @@ module KicksLiveness
   #
   # @see file:docs/DESIGN.md#why-the-heartbeat-file-has-no-require-of-its-own
   class Heartbeat
+    include GenerationGuard
+
     # @return [String] marks directory used when the environment says nothing
     DEFAULT_DIR = '/opt/app/tmp/health'.freeze
     # @return [Integer] seconds after which a mark is stale, by default
@@ -29,6 +83,16 @@ module KicksLiveness
       tick: 'KICKS_LIVENESS_TICK'
     }.freeze
 
+    # Linux exposes a stable identifier shared by a private-PID container and
+    # its exec probes. A restarted container gets a new identifier even though
+    # its Kubernetes emptyDir survives.
+    # @return [String, nil] current private-PID container incarnation, or nil
+    #   off Linux
+    # @api private
+    def self.container_generation
+      ContainerGeneration.current
+    end
+
     # An empty string counts as unset: in a ConfigMap that is what you get by
     # declaring a key and leaving it blank.
     #
@@ -72,9 +136,15 @@ module KicksLiveness
 
     # @param dir [String] marks directory
     # @param max_age [Integer] seconds after which a mark is considered stale
-    def initialize(dir: Heartbeat.env_dir, max_age: Heartbeat.env_max_age)
+    # @param generation [String, nil] container incarnation; injected in specs
+    def initialize(
+      dir: Heartbeat.env_dir,
+      max_age: Heartbeat.env_max_age,
+      generation: Heartbeat.container_generation
+    )
       @dir = dir
       @max_age = max_age
+      @generation = generation
     end
 
     attr_reader :dir, :max_age
@@ -93,10 +163,8 @@ module KicksLiveness
     # @return [void]
     def declare!(processes)
       make_dir
-      # The pid keeps concurrent forks from sharing the temporary file.
-      tmp = "#{expected_path}.#{Process.pid}"
-      File.write(tmp, processes)
-      File.rename(tmp, expected_path)
+      atomic_write(generation_path, @generation) if @generation
+      atomic_write(expected_path, processes)
     end
 
     # Refreshes this fork's mark.
@@ -106,14 +174,18 @@ module KicksLiveness
     # PID in the name that file would stay stale forever and the probe would fail
     # permanently.
     #
-    # The contents exist only for a human running <tt>kubectl exec ... cat</tt>;
-    # the probe decides on mtime alone.
+    # The timestamp, pid and slot exist for a human running
+    # <tt>kubectl exec ... cat</tt>. The generation is also checked by the probe:
+    # a Kubernetes emptyDir survives a container restart, so freshness alone
+    # cannot distinguish this process from the one that just exited.
     #
     # @param slot [Integer] supervisor slot of this fork
     # @return [Integer] bytes written
     def touch!(slot)
       make_dir
-      File.write(slot_path(slot), "#{Time.now.utc.strftime('%FT%TZ')} pid=#{Process.pid} slot=#{slot}\n")
+      contents = "#{Time.now.utc.strftime('%FT%TZ')} pid=#{Process.pid} slot=#{slot}"
+      contents = "#{contents} generation=#{@generation}" if @generation
+      atomic_write(slot_path(slot), "#{contents}\n")
     end
 
     # The probe side: is every declared fork's mark present and fresh?
@@ -126,13 +198,9 @@ module KicksLiveness
     def check(now: Time.now.utc)
       processes = expected
       return [false, "no #{expected_path}: worker has not started yet"] unless processes&.positive?
+      return [false, 'heartbeat belongs to a previous container: worker has not started yet'] unless current_generation?
 
-      problems = (0...processes).filter_map do |slot|
-        age = age_of(slot_path(slot), now)
-        next "worker-#{slot} missing" if age.nil?
-
-        "worker-#{slot} stale #{age.round}s > #{@max_age}s" if age > @max_age
-      end
+      problems = (0...processes).filter_map { |slot| problem_for(slot, now) }
 
       problems.empty? ? [true, "#{processes} process(es) healthy"] : [false, problems.join('; ')]
     end
@@ -169,6 +237,25 @@ module KicksLiveness
       nil
     end
 
+    def problem_for(slot, now)
+      path = slot_path(slot)
+      age = age_of(path, now)
+      return "worker-#{slot} missing" if age.nil?
+      return "worker-#{slot} belongs to a previous container" if previous_generation?(path)
+
+      "worker-#{slot} stale #{age.round}s > #{@max_age}s" if age > @max_age
+    rescue StandardError
+      "worker-#{slot} unreadable"
+    end
+
+    def atomic_write(path, contents)
+      # The pid keeps concurrent forks from sharing the temporary file.
+      tmp = "#{path}.#{Process.pid}"
+      bytes = File.write(tmp, contents)
+      File.rename(tmp, path)
+      bytes
+    end
+
     def age_of(path, now)
       now - File.mtime(path)
     rescue StandardError

data/lib/kicks_liveness/version.rb

@@ -1,4 +1,4 @@
 module KicksLiveness
   # @return [String] gem version
-  VERSION = '0.1.1'.freeze
+  VERSION = '0.1.2'.freeze
 end

data/lib/kicks_liveness.rb

@@ -9,8 +9,8 @@ require_relative 'kicks_liveness/hooks'
 # Liveness probe for Kicks and Sneakers workers, backed by a tmpfs heartbeat.
 #
 # The worker publishes a mark from inside its own process, checking its Bunny
-# consumers in memory; the probe reads only the mark's mtime. No Rails, no call
-# to the broker.
+# consumers in memory; the probe reads only the container generation and mark
+# mtimes. No Rails, no call to the broker.
 #
 # @see file:docs/SETUP.md
 # @see file:docs/DESIGN.md

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kicks_liveness
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - PoroshkinaVV
@@ -11,12 +11,8 @@ date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: |
   A liveness probe for RabbitMQ worker pods that loads no Rails and never talks
-  to the broker. The worker publishes a heartbeat to tmpfs from inside its own
-  process, checking its Bunny consumers in memory; the probe only reads the
-  file's mtime and runs as `bundle exec kicks-liveness`. It loads no application
-  code; aside from Bundler and the interpreter it loads only the gem's small
-  probe files, while the state itself comes from tmpfs. A broker hiccup cannot
-  restart every replica at once.
+  to the broker. Workers check their Bunny consumers in memory and publish a
+  heartbeat to tmpfs; the probe only reads that heartbeat.
 email:
 - lera.poroshkina@mail.ru
 executables:
@@ -49,7 +45,7 @@ licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/PoroshkinaVV/kicks_liveness
-  documentation_uri: https://rubydoc.info/gems/kicks_liveness/0.1.1
+  documentation_uri: https://rubydoc.info/gems/kicks_liveness/0.1.2
   changelog_uri: https://github.com/PoroshkinaVV/kicks_liveness/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/PoroshkinaVV/kicks_liveness/issues
   rubygems_mfa_required: 'true'