davsclaus opened a new pull request, #29359:
URL: https://github.com/apache/camel/pull/29359

   [CAMEL-26699](https://issues.apache.org/jira/browse/CAMEL-26699), part 2. 
When you add a chaos rule from the known rules, the add form had a one-line 
description and a lot of empty room. Each recipe of the chaos model now guides 
the one who picks it, a person or an AI:
   
   - **description**: what it does, now fuller. For example, "Is slow" adds 
that the exchange then goes on as usual: the cost is time, not errors.
   - **uncovers**: what it can uncover, such as "Redeliveries without a delay, 
which hit an overloaded service again at once".
   - **avoid**: when not to use it, such as "To test the timeout of the client: 
the wait is before the call, so the client's timeout does not fire. Use Times 
out".
   - **watch**: what to look at while it runs, such as "The mean, p95 and p99 
time of the routes, and their throughput".
   
   **camel-chaos**
   - `ChaosModel.guides()` has the three lists for each of the 17 recipes, and 
the recipes have the fuller descriptions.
   - The build writes them into `chaos-model.json` (`uncovers`, `avoid`, 
`watch`), and the catalog copy is updated.
   - `ChaosModelTest` checks that every recipe has all three.
   - The model section of `chaos.adoc` describes them, with a fuller example; 
the catalog doc copy is updated.
   
   **Terminal UI**
   - The add form shows "What it can uncover", "When not to use it" and "What 
to watch" as bullets, both under the rule of the recipe in focus and under the 
fields while it is filled in.
   - With a catalog from before this, the lists are empty and nothing is shown.
   - The help page of the chaos screen mentions it.
   
   How "Is slow" now looks in the form (rendered with the generated model; 170 
columns):
   
   ```
   │ > Is slow                                   │ Is slow                      
                                                                        │
   │   Times out                                 │ Each send waits a time 
within the range before it is made, as a slow service. The exchange then      │
   │   Did the work, then failed                 │ goes on as usual: the cost 
is time, not errors                                                       │
   │   Is down for a while                       │                              
                                                                        │
   │ Messages                                    │ endpoint=${endpoint} delay 
duration=${duration} rate=${rate} until=${until}                          │
   │   Arrives corrupt                           │                              
                                                                        │
   │   Is sent with an empty body                │ What it can uncover          
                                                                        │
   │   Is sent without a header                  │ • A consumer that falls 
behind: the throughput of the route drops and messages wait in front of it   │
   │ Consumers and routes                        │ • Thread pools that fill up 
with waiting exchanges                                                   │
   │   Polls fail                                │ • Callers of the route 
(request/reply) that time out                                                 │
   │   Polls are skipped                         │                              
                                                                        │
   │   The route stalls                          │ When not to use it           
                                                                        │
   │   The route flaps                           │ • To test the timeout of the 
client: the wait is before the call, so the client's timeout does not   │
   │   The route is removed                      │ fire. Use Times out          
                                                                        │
   │ Error handling                              │ • On a route started by a 
timer: the timer waits for the exchange, so there are fewer messages, not  │
   │   The dead letter channel is unreachable    │ more load                    
                                                                        │
   │   A step fails                              │                              
                                                                        │
   │   A step is slow                            │ What to watch                
                                                                        │
   │   Write the rule yourself …                 │ • The mean, p95 and p99 time 
of the routes, and their throughput                                     │
   │                                             │ • The exchanges in flight    
                                                                        │
   ```
   
   **Tests:** all 651 camel-chaos tests pass, and all 2328 TUI module tests 
pass (1 skipped). Not checked live: a running TUI loads camel-catalog from the 
local Maven repository, which doesn't have the new model yet.
   
   This is independent of #29358, the first part of CAMEL-26699; both touch 
`ChaosRecipes`, in different places.
   
   _Claude Code on behalf of Claus Ibsen_
   
   🤖 Generated with [Claude Code](https://claude.com/claude-code)
   
   https://claude.ai/code/session_012nJsFsjqqFiwroeHRWaKbS
   


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to