28762732885

Committed 06 Jul 2026 01:49AM UTC coverage: 90.336% (-0.1%) from 90.457%

Build # 28762732885

Build Type

push

github

Committed by

Hyshmily

Commit Message

fix: fix known bugs

Signed-off-by: Hyshmily <cxm8607@outlook.com>

Coverage Stats

1314 of 1518 branches covered (86.56%)

Branch coverage included in aggregate %.

72 of 80 new or added lines in 9 files covered. (90.0%)

2 existing lines in 2 files now uncovered.

3715 of 4049 relevant lines covered (91.75%)

4.18 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.16

/common/src/main/java/io/github/hyshmily/hotkey/detection/impl/HotKeyStateMachineImpl.java

/*
 * Copyright 2026 Hyshmily. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package io.github.hyshmily.hotkey.detection.impl;

import static io.github.hyshmily.hotkey.detection.HotKeyStateMachine.State.*;

import com.google.common.util.concurrent.Striped;
import io.github.hyshmily.hotkey.Internal;
import io.github.hyshmily.hotkey.detection.HotKeyStateMachine;
import io.github.hyshmily.hotkey.model.HotKeyDecision;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;

/**
 * Per-key state machine that governs hot-key lifecycle transitions on the
 * Worker side.
 *
 * <p>Each Worker shard owns a subset of keys (determined by
 * {@link io.github.hyshmily.hotkey.sharding.ConsistentHashRing} routing)
 * and runs one {@code HotKeyStateMachine} instance per owned shard. The
 * state machine converts per-key sliding-window frequency observations
 * into lifecycle transitions — promoting COLD keys to CONFIRMED_HOT when
 * sustained traffic is detected, and demoting them back to COLD after a
 * prolonged cool-down.
 *
 * <h3>State diagram</h3>
 * <pre>
 *   COLD
 *    │  hotStreak >= confirmCount  (consecutive hot windows)
 *    ▼
 *   CONFIRMED_HOT   ─────────────────────────────┐
 *    │                                           │
 *    │  coolStreak >= (coolCount - grace)        │ hotStreak > 0 (revive during pre-cool)
 *    ▼                                           │
 *   PRE_COOLING ─────────────────────────────────┘
 *    │
 *    │  coolStreak >= coolCount  (fully cooled)
 *    ▼
 *   COLD
 * </pre>
 *
 * <h3>Design rationale</h3>
 * <ul>
 *   <li><b>Fast detection:</b> only {@code confirmCount} consecutive hot windows are
 *       needed to promote a key to {@code CONFIRMED_HOT}.</li>
 *   <li><b>Slow cool-down:</b> cooling requires many more consecutive cold windows,
 *       with an intermediate {@code PRE_COOLING} grace period.  If traffic resumes
 *       during this period the key silently returns to {@code CONFIRMED_HOT} without
 *       broadcasting (no COOL → HOT oscillation).</li>
 *   <li><b>Asymmetric thresholds:</b> protect aggressively, recover cautiously.
 *       This prevents flapping when traffic is bursty or when the cluster briefly
 *       stops reporting a key.</li>
 * </ul>
 *
 * <p>Thread-safe: per-key state is guarded by a {@link Striped} lock (1024
 * stripes). Evaluations of different keys proceed in parallel; evaluations
 * of the same key are serialized, eliminating the race window between
 * {@code hotStreak++} and the state transition check caused by concurrent
 * delivery of the same key across multiple consumer threads.
 *
 * <p>Designed for single-shard workers; each key is owned by exactly one worker
 * thanks to consistent-hash routing on the client side.</p>
 */
@Internal
@Slf4j
@AllArgsConstructor
public class HotKeyStateMachineImpl implements HotKeyStateMachine {

  /** Number of consecutive hot windows required to promote COLD → CONFIRMED_HOT. */
  @Getter
  @Setter
  private volatile int confirmCount;

  /**
   * Total number of consecutive cold windows required for a full cool-down
   * (CONFIRMED_HOT → PRE_COOLING → COLD).  Must be greater than
   * {@code preCoolGraceCount}.
   */
  @Getter
  @Setter
  private volatile int coolCount;

  /**
   * The number of cold windows that mark the entry into PRE_COOLING.
   * The remaining {@code coolCount - preCoolGraceCount} windows are the
   * grace period during which the key can revive without a broadcast.
   */
  @Getter
  @Setter
  private volatile int preCoolGraceCount;

  /** Current state + streak counters, keyed by cache key. */
  private final ConcurrentHashMap<String, KeyState> states = new ConcurrentHashMap<>();

  /**
   * Last evaluation timestamp for each key.  Used by {@link #evictStale(long)}
   * to garbage-collect keys that have not been reported for an extended period.
   */
  private final ConcurrentHashMap<String, Long> stateTimestamps = new ConcurrentHashMap<>();

  /**
   * Per-key striped lock — serializes evaluations of the same key when
   * multiple consumer threads process overlapping messages, preventing
   * lost increments on {@code hotStreak++} / {@code coolStreak++}.
   *
   * <p>1024 stripes keep collision probability below 0.1% at
   * {@code concurrency=8} while adding negligible memory overhead.
   */
  private final Striped<Lock> keyLocks = Striped.lazyWeakLock(1024);

  /**
   * Evaluates the current sliding-window observation for the given key and
   * returns a decision instructing the caller whether to broadcast a HOT or
   * COOL message.
   *
   * <p>This method implements the state transitions described in the class
   * Javadoc. It updates the per-key streak counters ({@code hotStreak} /
   * {@code coolStreak}) atomically (via {@link ConcurrentHashMap#computeIfAbsent})
   * and returns one of:
   * <ul>
   *   <li>{@link HotKeyDecision.DecisionType#HOT} — key just crossed the
   *       promotion threshold; broadcast HOT to application instances.</li>
   *   <li>{@link HotKeyDecision.DecisionType#COOL} — key has fully cooled
   *       down; broadcast COOL so apps revert to normal TTL.</li>
   *   <li>{@link HotKeyDecision.DecisionType#NONE} — no state transition
   *       occurred; no action required.</li>
   * </ul>
   *
   * <p>Silent revive (PRE_COOLING → CONFIRMED_HOT) returns NONE to
   * suppress unnecessary broadcasts and prevent HOT/COOL oscillation.
   *
   * @param key             the cache key (must not be {@code null})
   * @param isHotThisWindow {@code true} if the sliding-window frequency sum
   *                        exceeds the hot threshold during this evaluation
   *                        cycle; {@code false} otherwise
   * @return a non-null {@link HotKeyDecision} indicating what action the
   *         caller should take (HOT, COOL, or NONE)
   */
  public HotKeyDecision evaluate(String key, boolean isHotThisWindow) {
    // Fast path: never-before-seen key on a cold window — no state to
    // mutate (no accumulated hotStreak to reset), skip striped-lock
    // acquisition entirely.
    if (!isHotThisWindow && !states.containsKey(key)) {
      return HotKeyDecision.none(key);
    }

    Lock lock = keyLocks.get(key);
    lock.lock();
    try {
      // Touch timestamp for eviction tracking
      stateTimestamps.put(key, System.currentTimeMillis());

      KeyState state = states.computeIfAbsent(key, k -> new KeyState());

      if (isHotThisWindow) {
        state.hotStreak++;
        state.coolStreak = 0; // reset cold streak

        // COLD → CONFIRMED_HOT transition
        if (state.currentState == COLD && state.hotStreak >= confirmCount) {
          state.currentState = CONFIRMED_HOT;
          return HotKeyDecision.hot(key); // broadcast HOT
        }

        // PRE_COOLING → CONFIRMED_HOT (silent revive)
        if (state.currentState == PRE_COOLING) {
          state.currentState = CONFIRMED_HOT;
          return HotKeyDecision.none(key); // no broadcast — avoid oscillation
        }
      } else {
        state.coolStreak++;
        state.hotStreak = 0; // reset hot streak

        // CONFIRMED_HOT → PRE_COOLING transition (first cool phase)
        if (state.currentState == CONFIRMED_HOT && state.coolStreak >= Math.max(1, coolCount - preCoolGraceCount)) {
          state.currentState = PRE_COOLING;
          // no broadcast yet — wait for full cool-down
        }

        // PRE_COOLING → COLD transition (fully cooled)
        if (state.currentState == PRE_COOLING && state.coolStreak >= coolCount) {
          state.currentState = COLD;
          return HotKeyDecision.cool(key); // broadcast COOL
        }
      }

      return HotKeyDecision.none(key);
    } catch (Exception e) {
      log.warn("Unexpected StateMachine Exception for key {}", key, e);
      return HotKeyDecision.none(key);
    } finally {
      lock.unlock();
    }
  }

  /**
   * Immediately removes all tracked state for the given key, effectively
   * resetting it to {@link State#COLD}.
   *
   * <p>Called when the Worker fails to obtain a version from Redis and must
   * abort the current HOT decision (e.g. Redis is unreachable or the key
   * was not found in Redis). After reset, the next {@link #evaluate} call
   * for this key will start from scratch with fresh streak counters.
   *
   * <p>The last-touch timestamp is intentionally not removed to prevent
   * immediate re-creation churn in {@link #evictStale} — it will be cleaned
   * up lazily on the next eviction cycle.
   *
   * @param key the cache key to reset
   */
  public void reset(String key) {
    states.remove(key);
    // stateTimestamps is cleaned up lazily by evictStale();
    // keeping the timestamp for a while avoids immediate re-creation churn.
  }

  /**
   * Approximate number of keys currently tracked by the state machine.
   * <p>The returned value is approximate due to the underlying
   * {@link java.util.concurrent.ConcurrentHashMap#size()} semantics
   * — it reflects a snapshot and may not account for concurrent
   * insertions or removals at the exact moment of the call.</p>
   *
   * @return approximate count of keys currently tracked
   */
  public int getTrackedKeys() {
    return states.size();
  }

  /**
   * Garbage-collects state for keys that have not been evaluated within
   * {@code staleAfterMs} milliseconds.  Should be invoked periodically
   * (e.g. every 5 seconds) from a scheduled task.
   *
   * @param staleAfterMs maximum idle time in milliseconds before a key is evicted
   */
  public void evictStale(long staleAfterMs) {
    long now = System.currentTimeMillis();
    // Single pass: remove stale state and its timestamp together
    states
      .keySet()
      .removeIf(key -> {
        Long last = stateTimestamps.get(key);
        if (last == null) {
          return false;
        }
        if (now - last > staleAfterMs) {
          stateTimestamps.remove(key);
          return true;
        }
        return false;
      });
    // Orphaned timestamps from reset() — only scan when needed
    if (states.size() < stateTimestamps.size()) {
      stateTimestamps.keySet().removeIf(k -> !states.containsKey(k));
    }
  }

  public Map<String, Object> getStateSnapshot(String key) {
    Lock lock = keyLocks.get(key);
    lock.lock();
    try {
      KeyState keyState = states.get(key);
      if (keyState == null) {
        return Collections.emptyMap();
      }
      return Map.of(
        "currentState",
        keyState.currentState.name(),
        "hotStreak",
        keyState.hotStreak,
        "coolStreak",
        keyState.coolStreak
      );
    } finally {
      lock.unlock();
    }
  }

  /**
   * Rolls back the per-key state to its previous value after a broadcast failure.
   * This allows the next evaluation window to re-emit the decision.
   *
   * @param key the key whose state machine should be rolled back
   */
  public void rollbackToPreviousState(String key, Map<String, Object> previousState) {
    Lock lock = keyLocks.get(key);
    lock.lock();
    try {
      if (previousState == null) {
        // No previous state; treat as reset
        reset(key);
        return;
      }

      KeyState keyState = states.computeIfAbsent(key, k -> new KeyState());
      keyState.currentState = State.valueOf((String) previousState.get("currentState"));
      keyState.hotStreak = (int) previousState.get("hotStreak");
      keyState.coolStreak = (int) previousState.get("coolStreak");
    } finally {
      lock.unlock();
    }
  }

  private static class KeyState {

    /** Current lifecycle stage. */
    volatile State currentState = COLD;

    /** Number of consecutive windows above the hot threshold. */
    volatile int hotStreak = 0;

    /** Number of consecutive windows below the hot threshold. */
    volatile int coolStreak = 0;
  }
}

1	/*
2	* Copyright 2026 Hyshmily. All Rights Reserved.
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package io.github.hyshmily.hotkey.detection.impl;
17
18	import static io.github.hyshmily.hotkey.detection.HotKeyStateMachine.State.*;
19
20	import com.google.common.util.concurrent.Striped;
21	import io.github.hyshmily.hotkey.Internal;
22	import io.github.hyshmily.hotkey.detection.HotKeyStateMachine;
23	import io.github.hyshmily.hotkey.model.HotKeyDecision;
24	import java.util.Collections;
25	import java.util.Map;
26	import java.util.concurrent.ConcurrentHashMap;
27	import java.util.concurrent.locks.Lock;
28	import lombok.AllArgsConstructor;
29	import lombok.Getter;
30	import lombok.Setter;
31	import lombok.extern.slf4j.Slf4j;
32
33	/**
34	* Per-key state machine that governs hot-key lifecycle transitions on the
35	* Worker side.
36	*
37	* <p>Each Worker shard owns a subset of keys (determined by
38	* {@link io.github.hyshmily.hotkey.sharding.ConsistentHashRing} routing)
39	* and runs one {@code HotKeyStateMachine} instance per owned shard. The
40	* state machine converts per-key sliding-window frequency observations
41	* into lifecycle transitions — promoting COLD keys to CONFIRMED_HOT when
42	* sustained traffic is detected, and demoting them back to COLD after a
43	* prolonged cool-down.
44	*
45	* <h3>State diagram</h3>
46	* <pre>
47	* COLD
48	* │ hotStreak >= confirmCount (consecutive hot windows)
49	* ▼
50	* CONFIRMED_HOT ─────────────────────────────┐
51	* │ │
52	* │ coolStreak >= (coolCount - grace) │ hotStreak > 0 (revive during pre-cool)
53	* ▼ │
54	* PRE_COOLING ─────────────────────────────────┘
55	* │
56	* │ coolStreak >= coolCount (fully cooled)
57	* ▼
58	* COLD
59	* </pre>
60	*
61	* <h3>Design rationale</h3>
62	* <ul>
63	* <li><b>Fast detection:</b> only {@code confirmCount} consecutive hot windows are
64	* needed to promote a key to {@code CONFIRMED_HOT}.</li>
65	* <li><b>Slow cool-down:</b> cooling requires many more consecutive cold windows,
66	* with an intermediate {@code PRE_COOLING} grace period. If traffic resumes
67	* during this period the key silently returns to {@code CONFIRMED_HOT} without
68	* broadcasting (no COOL → HOT oscillation).</li>
69	* <li><b>Asymmetric thresholds:</b> protect aggressively, recover cautiously.
70	* This prevents flapping when traffic is bursty or when the cluster briefly
71	* stops reporting a key.</li>
72	* </ul>
73	*
74	* <p>Thread-safe: per-key state is guarded by a {@link Striped} lock (1024
75	* stripes). Evaluations of different keys proceed in parallel; evaluations
76	* of the same key are serialized, eliminating the race window between
77	* {@code hotStreak++} and the state transition check caused by concurrent
78	* delivery of the same key across multiple consumer threads.
79	*
80	* <p>Designed for single-shard workers; each key is owned by exactly one worker
81	* thanks to consistent-hash routing on the client side.</p>
82	*/
83	@Internal
84	@Slf4j	4✔
85	@AllArgsConstructor
86	public class HotKeyStateMachineImpl implements HotKeyStateMachine {
87
88	/** Number of consecutive hot windows required to promote COLD → CONFIRMED_HOT. */
89	@Getter
90	@Setter
91	private volatile int confirmCount;
92
93	/**
94	* Total number of consecutive cold windows required for a full cool-down
95	* (CONFIRMED_HOT → PRE_COOLING → COLD). Must be greater than
96	* {@code preCoolGraceCount}.
97	*/
98	@Getter
99	@Setter
100	private volatile int coolCount;
101
102	/**
103	* The number of cold windows that mark the entry into PRE_COOLING.
104	* The remaining {@code coolCount - preCoolGraceCount} windows are the
105	* grace period during which the key can revive without a broadcast.
106	*/
107	@Getter
108	@Setter
109	private volatile int preCoolGraceCount;
110
111	/** Current state + streak counters, keyed by cache key. */
112	private final ConcurrentHashMap<String, KeyState> states = new ConcurrentHashMap<>();
113
114	/**
115	* Last evaluation timestamp for each key. Used by {@link #evictStale(long)}
116	* to garbage-collect keys that have not been reported for an extended period.
117	*/
118	private final ConcurrentHashMap<String, Long> stateTimestamps = new ConcurrentHashMap<>();
119
120	/**
121	* Per-key striped lock — serializes evaluations of the same key when
122	* multiple consumer threads process overlapping messages, preventing
123	* lost increments on {@code hotStreak++} / {@code coolStreak++}.
124	*
125	* <p>1024 stripes keep collision probability below 0.1% at
126	* {@code concurrency=8} while adding negligible memory overhead.
127	*/
128	private final Striped<Lock> keyLocks = Striped.lazyWeakLock(1024);
129
130	/**
131	* Evaluates the current sliding-window observation for the given key and
132	* returns a decision instructing the caller whether to broadcast a HOT or
133	* COOL message.
134	*
135	* <p>This method implements the state transitions described in the class
136	* Javadoc. It updates the per-key streak counters ({@code hotStreak} /
137	* {@code coolStreak}) atomically (via {@link ConcurrentHashMap#computeIfAbsent})
138	* and returns one of:
139	* <ul>
140	* <li>{@link HotKeyDecision.DecisionType#HOT} — key just crossed the
141	* promotion threshold; broadcast HOT to application instances.</li>
142	* <li>{@link HotKeyDecision.DecisionType#COOL} — key has fully cooled
143	* down; broadcast COOL so apps revert to normal TTL.</li>
144	* <li>{@link HotKeyDecision.DecisionType#NONE} — no state transition
145	* occurred; no action required.</li>
146	* </ul>
147	*
148	* <p>Silent revive (PRE_COOLING → CONFIRMED_HOT) returns NONE to
149	* suppress unnecessary broadcasts and prevent HOT/COOL oscillation.
150	*
151	* @param key the cache key (must not be {@code null})
152	* @param isHotThisWindow {@code true} if the sliding-window frequency sum
153	* exceeds the hot threshold during this evaluation
154	* cycle; {@code false} otherwise
155	* @return a non-null {@link HotKeyDecision} indicating what action the
156	* caller should take (HOT, COOL, or NONE)
157	*/
158	public HotKeyDecision evaluate(String key, boolean isHotThisWindow) {
159	// Fast path: never-before-seen key on a cold window — no state to
160	// mutate (no accumulated hotStreak to reset), skip striped-lock
161	// acquisition entirely.
162	if (!isHotThisWindow && !states.containsKey(key)) {	7✔
163	return HotKeyDecision.none(key);	3✔
164	}
165
166	Lock lock = keyLocks.get(key);	6✔
167	lock.lock();	2✔
168	try {
169	// Touch timestamp for eviction tracking
170	stateTimestamps.put(key, System.currentTimeMillis());	7✔
171
172	KeyState state = states.computeIfAbsent(key, k -> new KeyState());	11✔
173
174	if (isHotThisWindow) {	2✔
175	state.hotStreak++;	6✔
176	state.coolStreak = 0; // reset cold streak	3✔
177
178	// COLD → CONFIRMED_HOT transition
179	if (state.currentState == COLD && state.hotStreak >= confirmCount) {	9✔
180	state.currentState = CONFIRMED_HOT;	3✔
181	return HotKeyDecision.hot(key); // broadcast HOT	5✔
182	}
183
184	// PRE_COOLING → CONFIRMED_HOT (silent revive)
185	if (state.currentState == PRE_COOLING) {	4✔
186	state.currentState = CONFIRMED_HOT;	3✔
187	return HotKeyDecision.none(key); // no broadcast — avoid oscillation	5✔
188	}
189	} else {
190	state.coolStreak++;	6✔
191	state.hotStreak = 0; // reset hot streak	3✔
192
193	// CONFIRMED_HOT → PRE_COOLING transition (first cool phase)
194	if (state.currentState == CONFIRMED_HOT && state.coolStreak >= Math.max(1, coolCount - preCoolGraceCount)) {	14✔
195	state.currentState = PRE_COOLING;	3✔
196	// no broadcast yet — wait for full cool-down
197	}
198
199	// PRE_COOLING → COLD transition (fully cooled)
200	if (state.currentState == PRE_COOLING && state.coolStreak >= coolCount) {	9✔
201	state.currentState = COLD;	3✔
202	return HotKeyDecision.cool(key); // broadcast COOL	5✔
203	}
204	}
205
206	return HotKeyDecision.none(key);	5✔
207	} catch (Exception e) {	×
208	log.warn("Unexpected StateMachine Exception for key {}", key, e);	×
209	return HotKeyDecision.none(key);	×
210	} finally {
211	lock.unlock();	2✔
212	}
213	}
214
215	/**
216	* Immediately removes all tracked state for the given key, effectively
217	* resetting it to {@link State#COLD}.
218	*
219	* <p>Called when the Worker fails to obtain a version from Redis and must
220	* abort the current HOT decision (e.g. Redis is unreachable or the key
221	* was not found in Redis). After reset, the next {@link #evaluate} call
222	* for this key will start from scratch with fresh streak counters.
223	*
224	* <p>The last-touch timestamp is intentionally not removed to prevent
225	* immediate re-creation churn in {@link #evictStale} — it will be cleaned
226	* up lazily on the next eviction cycle.
227	*
228	* @param key the cache key to reset
229	*/
230	public void reset(String key) {
231	states.remove(key);	5✔
232	// stateTimestamps is cleaned up lazily by evictStale();
233	// keeping the timestamp for a while avoids immediate re-creation churn.
234	}	1✔
235
236	/**
237	* Approximate number of keys currently tracked by the state machine.
238	* <p>The returned value is approximate due to the underlying
239	* {@link java.util.concurrent.ConcurrentHashMap#size()} semantics
240	* — it reflects a snapshot and may not account for concurrent
241	* insertions or removals at the exact moment of the call.</p>
242	*
243	* @return approximate count of keys currently tracked
244	*/
245	public int getTrackedKeys() {
246	return states.size();	4✔
247	}
248
249	/**
250	* Garbage-collects state for keys that have not been evaluated within
251	* {@code staleAfterMs} milliseconds. Should be invoked periodically
252	* (e.g. every 5 seconds) from a scheduled task.
253	*
254	* @param staleAfterMs maximum idle time in milliseconds before a key is evicted
255	*/
256	public void evictStale(long staleAfterMs) {
257	long now = System.currentTimeMillis();	2✔
258	// Single pass: remove stale state and its timestamp together
259	states	2✔
260	.keySet()	5✔
261	.removeIf(key -> {	2✔
262	Long last = stateTimestamps.get(key);	6✔
263	if (last == null) {	2!
NEW 264	return false;	×
265	}
266	if (now - last > staleAfterMs) {	7!
267	stateTimestamps.remove(key);	5✔
268	return true;	2✔
269	}
NEW 270	return false;	×
271	});
272	// Orphaned timestamps from reset() — only scan when needed
273	if (states.size() < stateTimestamps.size()) {	7✔
274	stateTimestamps.keySet().removeIf(k -> !states.containsKey(k));	15!
275	}
276	}	1✔
277
278	public Map<String, Object> getStateSnapshot(String key) {
279	Lock lock = keyLocks.get(key);	6✔
280	lock.lock();	2✔
281	try {
282	KeyState keyState = states.get(key);	6✔
283	if (keyState == null) {	2✔
284	return Collections.emptyMap();	4✔
285	}
286	return Map.of(	7✔
287	"currentState",
288	keyState.currentState.name(),	4✔
289	"hotStreak",
290	keyState.hotStreak,	4✔
291	"coolStreak",
292	keyState.coolStreak	1✔
293	);
294	} finally {
295	lock.unlock();	2✔
296	}
297	}
298
299	/**
300	* Rolls back the per-key state to its previous value after a broadcast failure.
301	* This allows the next evaluation window to re-emit the decision.
302	*
303	* @param key the key whose state machine should be rolled back
304	*/
305	public void rollbackToPreviousState(String key, Map<String, Object> previousState) {
306	Lock lock = keyLocks.get(key);	6✔
307	lock.lock();	2✔
308	try {
309	if (previousState == null) {	2✔
310	// No previous state; treat as reset
311	reset(key);	3✔
312	return;	1✔
313	}
314
315	KeyState keyState = states.computeIfAbsent(key, k -> new KeyState());	11✔
316	keyState.currentState = State.valueOf((String) previousState.get("currentState"));	7✔
317	keyState.hotStreak = (int) previousState.get("hotStreak");	7✔
318	keyState.coolStreak = (int) previousState.get("coolStreak");	7✔
319	} finally {
320	lock.unlock();	2✔
321	}
322	}	1✔
323
324	private static class KeyState {	2✔
325
326	/** Current lifecycle stage. */
327	volatile State currentState = COLD;	3✔
328
329	/** Number of consecutive windows above the hot threshold. */
330	volatile int hotStreak = 0;	3✔
331
332	/** Number of consecutive windows below the hot threshold. */
333	volatile int coolStreak = 0;	4✔
334	}
335	}

Hyshmily / hotkey / 28762732885

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous