Split 'show memory_breakdown' into two commands

one for reporting absolute values (in bytes),
another for reporting relative values
(in percent).

Author: michaelklishin

CHANGELOG.md

@@ -1,11 +1,85 @@
 # rabbitmqadmin-ng Change Log
 
-## v0.19.0 (in development)
+## v0.19.0 (Jan 5, 2025)
 
-No (documented) changes yet
+### Enhancements
+
+ * Two new commands for reasoning about target [node's memory footprint](https://www.rabbitmq.com/docs/memory-use):
+
+   ```shell
+   # displays a breakdown in bytes
+   rabbitmqadmin show memory_breakdown_in_bytes --node 'rabbit@hostname'
+   ```
+
+   ```shell
+   # displays a breakdown in percent
+   rabbitmqadmin show memory_breakdown_in_percent --node 'rabbit@sunnyside'
+   ```
+   
+   Example output of `show memory_breakdown_in_percent`:
+
+   ```
+    ┌────────────────────────────────────────┬────────────┐
+    │ key                                    │ percentage │
+    ├────────────────────────────────────────┼────────────┤
+    │ total                                  │ 100%       │
+    ├────────────────────────────────────────┼────────────┤
+    │ Binary heap                            │ 45.10%     │
+    ├────────────────────────────────────────┼────────────┤
+    │ Allocated but unused                   │ 23.45%     │
+    ├────────────────────────────────────────┼────────────┤
+    │ Quorum queue ETS tables                │ 23.05%     │
+    ├────────────────────────────────────────┼────────────┤
+    │ Other processes                        │ 5.32%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Other (used by the runtime)            │ 4.98%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Code                                   │ 4.54%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Client connections: others processes   │ 3.64%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Management stats database              │ 3.48%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Client connections: reader processes   │ 3.22%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Plugins and their data                 │ 3.12%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Other (ETS tables)                     │ 1.55%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Metrics data                           │ 0.66%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ AMQP 0-9-1 channels                    │ 0.40%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Message store indices                  │ 0.27%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Atom table                             │ 0.24%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Client connections: writer processes   │ 0.19%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Quorum queue replica processes         │ 0.10%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Stream replica processes               │ 0.07%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Mnesia                                 │ 0.02%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Metadata store                         │ 0.02%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Stream coordinator processes           │ 0.02%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Classic queue processes                │ 0.00%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Metadata store ETS tables              │ 0.00%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Stream replica reader processes        │ 0.00%      │
+    ├────────────────────────────────────────┼────────────┤
+    │ Reserved by the kernel but unallocated │ 0.00%      │
+    └────────────────────────────────────────┴────────────┘
+
+   ```
+   
 
 
-## v0.18.0 (Jan 1, 2024)
+## v0.18.0 (Jan 1, 2025)
 
 ### Enhancements
 

Cargo.lock

@@ -17,7 +17,7 @@ reqwest = { version = "0.12.12", features = [
     "__rustls",
     "rustls-tls-native-roots"
 ]}
-rabbitmq_http_client = { git = "https://github.com/michaelklishin/rabbitmq-http-api-rs.git", features = [
+rabbitmq_http_client = { version = "0.15.0", features = [
     "core",
     "blocking",
     "tabled"

Cargo.toml

@@ -754,14 +754,14 @@ fn declare_subcommands() -> [Command; 11] {
     ]
 }
 
-fn show_subcommands() -> [Command; 4] {
+fn show_subcommands() -> [Command; 5] {
     let overview_cmd = Command::new("overview")
         .about("displays a essential information about target node and its cluster");
     let churn_cmd = Command::new("churn").about("displays object churn metrics");
     let endpoint_cmd = Command::new("endpoint")
         .about("for troubleshooting: displays the computed HTTP API endpoint URI");
-    let memory_breakdown_cmd = Command::new("memory_breakdown")
-        .about("use it to understand what consumes memory on the target node")
+    let memory_breakdown_in_bytes_cmd = Command::new("memory_breakdown_in_bytes")
+        .about("provides a memory footprint breakdown (in bytes) for the target node")
         .arg(
             Arg::new("node")
                 .long("node")
@@ -773,7 +773,26 @@ fn show_subcommands() -> [Command; 4] {
             MEMORY_FOOTPRINT_GUIDE_URL
         ));
 
-    [overview_cmd, churn_cmd, endpoint_cmd, memory_breakdown_cmd]
+    let memory_breakdown_in_percent_cmd = Command::new("memory_breakdown_in_percent")
+        .about("provides a memory footprint breakdown (in percent) for the target node")
+        .arg(
+            Arg::new("node")
+                .long("node")
+                .help("target node, must be a cluster member")
+                .required(true),
+        )
+        .after_long_help(color_print::cformat!(
+            "<bold>Doc guide:</bold>: {}",
+            MEMORY_FOOTPRINT_GUIDE_URL
+        ));
+
+    [
+        overview_cmd,
+        churn_cmd,
+        endpoint_cmd,
+        memory_breakdown_in_bytes_cmd,
+        memory_breakdown_in_percent_cmd,
+    ]
 }
 
 fn delete_subcommands() -> [Command; 11] {

src/cli.rs

@@ -253,9 +253,13 @@ fn dispatch_subcommand(
             println!("Using endpoint: {}", endpoint);
             res_handler.no_output_on_success(Ok(()))
         }
-        ("show", "memory_breakdown") => {
+        ("show", "memory_breakdown_in_bytes") => {
             let result = commands::show_memory_breakdown(client, command_args);
-            res_handler.memory_breakdown_result(result)
+            res_handler.memory_breakdown_in_bytes_result(result)
+        }
+        ("show", "memory_breakdown_in_percent") => {
+            let result = commands::show_memory_breakdown(client, command_args);
+            res_handler.memory_breakdown_in_percent_result(result)
         }
 
         ("list", "nodes") => {

src/main.rs

@@ -130,12 +130,29 @@ impl ResultHandler {
         }
     }
 
-    pub fn memory_breakdown_result(&mut self, result: ClientResult<NodeMemoryBreakdown>) {
+    pub fn memory_breakdown_in_bytes_result(&mut self, result: ClientResult<NodeMemoryBreakdown>) {
         match result {
             Ok(output) => {
                 self.exit_code = Some(ExitCode::Ok);
 
-                let mut table = tables::memory_breakdown(output);
+                let mut table = tables::memory_breakdown_in_bytes(output);
+                self.table_styler.apply(&mut table);
+
+                println!("{}", table);
+            }
+            Err(error) => self.report_command_run_error(&error),
+        }
+    }
+
+    pub fn memory_breakdown_in_percent_result(
+        &mut self,
+        result: ClientResult<NodeMemoryBreakdown>,
+    ) {
+        match result {
+            Ok(output) => {
+                self.exit_code = Some(ExitCode::Ok);
+
+                let mut table = tables::memory_breakdown_in_percent(output);
                 self.table_styler.apply(&mut table);
 
                 println!("{}", table);