@@ -114,7 +114,7 @@ public class TimeoutRegistry {
 
 3. **Enforce the limit**
 
-   `TimeoutExecutor` runs the call on a worker thread and waits for at most the configured duration. On a timeout it cancels the worker with an interrupt, logs the event, counts it in `TimeoutMetrics`, and returns the fallback. A failure raised by the service is not a timeout and is rethrown as `ServiceCallException`.
+   `TimeoutExecutor` runs the call on a worker thread and waits for at most the configured duration. On a timeout it cancels the worker with an interrupt, logs the event, counts it in `TimeoutMetrics`, and returns the fallback. A failure raised by the service, or a call the pool refuses to accept, is not a timeout and is rethrown as `ServiceCallException`.
 
 ```java
 @Slf4j
@@ -130,8 +130,9 @@ public class TimeoutExecutor implements AutoCloseable {
   public <T> T execute(TimeoutPolicy policy, Callable<T> call, Supplier<T> fallback) {
     var serviceName = policy.serviceName();
     var limitMillis = policy.timeout().toMillis();
-    var future = executor.submit(call);
+    Future<T> future = null;
     try {
+      future = executor.submit(call);
       var result = future.get(limitMillis, TimeUnit.MILLISECONDS);
       LOGGER.info("{} responded within its {} ms limit", serviceName, limitMillis);
       return result;
@@ -147,6 +148,8 @@ public class TimeoutExecutor implements AutoCloseable {
       future.cancel(true);
       Thread.currentThread().interrupt();
       throw new ServiceCallException(serviceName, e);
+    } catch (RejectedExecutionException e) {
+      throw new ServiceCallException(serviceName, e);
     }
   }
 
@@ -237,9 +240,71 @@ Recommendations shown to alice: [Wireless mouse, Webcam]
 Timeouts per service: {recommendations=1}
 ```
 
-## Class diagram
+The "exceeded its 100 ms limit" line is written by the caller and the "interrupted, abandoning" line by the worker thread, so the two may appear in either order from run to run.
+
+## Class Diagram
+
+```mermaid
+classDiagram
+    class TimeoutPolicy {
+        <<record>>
+        +String serviceName
+        +Duration timeout
+        +of(serviceName, millis)$ TimeoutPolicy
+    }
+    class TimeoutRegistry {
+        -Map~String, TimeoutPolicy~ policies
+        -Duration defaultTimeout
+        +register(policy) TimeoutRegistry
+        +policyFor(serviceName) TimeoutPolicy
+    }
+    class TimeoutMetrics {
+        -ConcurrentMap~String, AtomicInteger~ timeouts
+        +recordTimeout(serviceName) void
+        +timeoutCount(serviceName) int
+        +snapshot() SortedMap~String, Integer~
+    }
+    class TimeoutExecutor {
+        -ExecutorService executor
+        -TimeoutMetrics metrics
+        +execute(policy, call, fallback) T
+        +metrics() TimeoutMetrics
+        +close() void
+    }
+    class ServiceCallException {
+        +ServiceCallException(serviceName, cause)
+    }
+    class ProductCatalogService {
+        +String NAME$
+        -Duration latency
+        +fetchProducts() List~String~
+    }
+    class RecommendationService {
+        +String NAME$
+        -Duration latency
+        +recommendationsFor(customer) List~String~
+    }
+    class App {
+        -List~String~ POPULAR_ITEMS$
+        +main(args)$ void
+        ~loadProducts(executor, registry, catalog)$ List~String~
+        ~loadRecommendations(executor, registry, recommendations, customer)$ List~String~
+    }
+
+    ServiceCallException --|> RuntimeException
+    TimeoutRegistry --> "*" TimeoutPolicy : holds
+    TimeoutExecutor --> TimeoutMetrics : counts timeouts in
+    TimeoutExecutor ..> TimeoutPolicy : reads the limit from
+    TimeoutExecutor ..> ServiceCallException : throws
+    App ..> TimeoutRegistry : configures
+    App ..> TimeoutPolicy : registers
+    App ..> TimeoutExecutor : calls through
+    App ..> TimeoutMetrics : reports
+    App ..> ProductCatalogService : calls
+    App ..> RecommendationService : calls
+```
 
-See [timeout.urm.puml](./etc/timeout.urm.puml) for the PlantUML class diagram.
+The same diagram is kept as PlantUML in [timeout.urm.puml](./etc/timeout.urm.puml).
 
 ## When to Use the Timeout Pattern in Java
 
 
@@ -1,6 +1,6 @@
 @startuml
 package com.iluwatar.timeout {
-  class TimeoutPolicy {
+  class TimeoutPolicy <<record>> {
     - serviceName : String
     - timeout : Duration
     + TimeoutPolicy(serviceName : String, timeout : Duration)
@@ -20,7 +20,7 @@ package com.iluwatar.timeout {
     + TimeoutMetrics()
     + recordTimeout(serviceName : String) : void
     + timeoutCount(serviceName : String) : int
-    + snapshot() : Map<String, Integer>
+    + snapshot() : SortedMap<String, Integer>
   }
   class TimeoutExecutor {
     - executor : ExecutorService
@@ -48,18 +48,20 @@ package com.iluwatar.timeout {
   }
   class App {
     - POPULAR_ITEMS : List<String> {static}
-    + App()
     + main(args : String[]) : void
     ~ loadProducts(executor : TimeoutExecutor, registry : TimeoutRegistry, catalog : ProductCatalogService) : List<String> {static}
     ~ loadRecommendations(executor : TimeoutExecutor, registry : TimeoutRegistry, recommendations : RecommendationService, customer : String) : List<String> {static}
   }
 }
+ServiceCallException --|> RuntimeException
 TimeoutExecutor --> TimeoutMetrics
 TimeoutExecutor ..> TimeoutPolicy
 TimeoutExecutor ..> ServiceCallException
 TimeoutRegistry --> "*" TimeoutPolicy
 App ..> TimeoutRegistry
+App ..> TimeoutPolicy
 App ..> TimeoutExecutor
+App ..> TimeoutMetrics
 App ..> ProductCatalogService
 App ..> RecommendationService
 @enduml
@@ -29,6 +29,8 @@
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.function.Supplier;
@@ -71,13 +73,15 @@ public TimeoutExecutor(ExecutorService executor) {
    * @param fallback answer to use when the call does not complete in time
    * @param <T> type of the response
    * @return the response of the call, or the fallback if the limit was exceeded
-   * @throws ServiceCallException if the call fails or the waiting thread is interrupted
+   * @throws ServiceCallException if the call cannot be submitted, fails, or the waiting thread is
+   *     interrupted
    */
   public <T> T execute(TimeoutPolicy policy, Callable<T> call, Supplier<T> fallback) {
     var serviceName = policy.serviceName();
     var limitMillis = policy.timeout().toMillis();
-    var future = executor.submit(call);
+    Future<T> future = null;
     try {
+      future = executor.submit(call);
       var result = future.get(limitMillis, TimeUnit.MILLISECONDS);
       LOGGER.info("{} responded within its {} ms limit", serviceName, limitMillis);
       return result;
@@ -93,6 +97,8 @@ public <T> T execute(TimeoutPolicy policy, Callable<T> call, Supplier<T> fallbac
       future.cancel(true);
       Thread.currentThread().interrupt();
       throw new ServiceCallException(serviceName, e);
+    } catch (RejectedExecutionException e) {
+      throw new ServiceCallException(serviceName, e);
     }
   }
 
 
@@ -24,7 +24,8 @@
  */
 package com.iluwatar.timeout;
 
-import java.util.Map;
+import java.util.Collections;
+import java.util.SortedMap;
 import java.util.TreeMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
@@ -63,9 +64,9 @@ public int timeoutCount(String serviceName) {
    *
    * @return service name to timeout count
    */
-  public Map<String, Integer> snapshot() {
+  public SortedMap<String, Integer> snapshot() {
     var snapshot = new TreeMap<String, Integer>();
     timeouts.forEach((name, counter) -> snapshot.put(name, counter.get()));
-    return Map.copyOf(snapshot);
+    return Collections.unmodifiableSortedMap(snapshot);
   }
 }
@@ -30,6 +30,7 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CountDownLatch;
@@ -129,6 +130,17 @@ void countsTimeoutsPerService() {
     assertEquals(Map.of("strict", 2, "other", 1), executor.metrics().snapshot());
   }
 
+  @Test
+  void keepsSnapshotSortedByServiceName() {
+    var metrics = executor.metrics();
+    metrics.recordTimeout("payments");
+    metrics.recordTimeout("analytics");
+    metrics.recordTimeout("catalog");
+
+    assertEquals(
+        List.of("analytics", "catalog", "payments"), List.copyOf(metrics.snapshot().keySet()));
+  }
+
   @Test
   void propagatesInterruptionOfTheCaller() {
     Callable<String> slowCall =
@@ -152,8 +164,12 @@ void propagatesInterruptionOfTheCaller() {
   void rejectsCallsAfterClose() {
     executor.close();
 
-    assertThrows(
-        RejectedExecutionException.class,
-        () -> executor.execute(GENEROUS, () -> "ignored", () -> "fallback"));
+    var thrown =
+        assertThrows(
+            ServiceCallException.class,
+            () -> executor.execute(GENEROUS, () -> "ignored", () -> "fallback"));
+
+    assertInstanceOf(RejectedExecutionException.class, thrown.getCause());
+    assertEquals(0, executor.metrics().timeoutCount(GENEROUS.serviceName()));
   }
 }