Same for bytes_written

Author: GeorgeHahn

CHANGELOG.md

@@ -6,8 +6,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 ## Fixed
-- Component name labels have been removed from the `bytes_received` metric to
-  fix egress throughput optimization goal analysis.
+- Labels have been removed from the `bytes_received` and `bytes_written` metrics
+   to fix some scenarios where they could break optimization goal analysis.
 ## Changed
 - Lading now built with edition 2024
 

lading/src/generator/file_gen/logrotate.rs

@@ -411,7 +411,11 @@ async fn write_bytes(
         fp.write_all(&blk.bytes)
             .await
             .map_err(|err| Error::IoWriteAll { err })?;
-        counter!("bytes_written", labels).increment(total_bytes);
+
+        // This metric must be written with a single context or it will crash
+        // analysis. The simple way to accomplish that is to attach no labels to
+        // it.
+        counter!("bytes_written").increment(total_bytes);
         *total_bytes_written += total_bytes;
     }
 

lading/src/generator/file_gen/logrotate_fs/model.rs

@@ -198,7 +198,11 @@ impl File {
         let diff = now.saturating_sub(self.modified_tick);
         let bytes_accum = diff.saturating_mul(self.bytes_per_tick);
 
+        // This metric must be written with a single context or it will crash
+        // analysis. The simple way to accomplish that is to attach no labels to
+        // it.
         counter!("bytes_written").increment(bytes_accum);
+
         self.bytes_written = self.bytes_written.saturating_add(bytes_accum);
         self.modified_tick = now;
         self.status_tick = now;

lading/src/generator/file_gen/traditional.rs

@@ -269,6 +269,10 @@ impl Child {
 
                     {
                         fp.write_all(&blk.bytes).await?;
+
+                        // This metric must be written with a single context or
+                        // it will crash analysis. The simple way to accomplish
+                        // that is to attach no labels to it.
                         counter!("bytes_written").increment(total_bytes);
                         total_bytes_written += total_bytes;
                     }

lading/src/generator/grpc.rs

@@ -289,7 +289,11 @@ impl Grpc {
 
                     match res {
                         Ok(res) => {
-                            counter!("bytes_written", &self.metric_labels).increment(block_length as u64);
+                            // This metric must be written with a single context
+                            // or it will crash analysis. The simple way to
+                            // accomplish that is to attach no labels to it.
+                            counter!("bytes_written").increment(block_length as u64);
+
                             counter!("request_ok", &self.metric_labels).increment(1);
                             counter!("response_bytes", &self.metric_labels).increment(res.into_inner() as u64);
                         }

lading/src/generator/http.rs

@@ -236,7 +236,11 @@ impl Http {
                         counter!("requests_sent", &labels).increment(1);
                         match client.request(request).await {
                             Ok(response) => {
-                                counter!("bytes_written", &labels).increment(block_length as u64);
+                                // This metric must be written with a single
+                                // context or it will crash analysis. The simple
+                                // way to accomplish that is to attach no labels
+                                // to it.
+                                counter!("bytes_written").increment(block_length as u64);
                                 let status = response.status();
                                 let mut status_labels = labels.clone();
                                 status_labels

lading/src/generator/passthru_file.rs

@@ -178,7 +178,10 @@ impl PassthruFile {
                     let blk = rcv.next().await.expect("failed to advance through the blocks"); // actually advance through the blocks
                     match current_file.write_all(&blk.bytes).await {
                         Ok(()) => {
-                            counter!("bytes_written", &self.metric_labels).increment(u64::from(blk.total_bytes.get()));
+                            // This metric must be written with a single context
+                            // or it will crash analysis. The simple way to
+                            // accomplish that is to attach no labels to it.
+                            counter!("bytes_written").increment(u64::from(blk.total_bytes.get()));
                         }
                         Err(err) => {
                             warn!("write failed: {}", err);

lading/src/generator/splunk_hec.rs

@@ -344,7 +344,11 @@ where
             match tm {
                 Ok(tm) => match tm {
                     Ok(response) => {
-                        counter!("bytes_written", &labels).increment(block_length as u64);
+                        // This metric must be written with a single context or
+                        // it will crash analysis. The simple way to accomplish
+                        // that is to attach no labels to it.
+                        counter!("bytes_written").increment(block_length as u64);
+
                         let (parts, body) = response.into_parts();
                         let status = parts.status;
                         let mut status_labels = labels.clone();

lading/src/generator/tcp.rs

@@ -181,7 +181,11 @@ impl Tcp {
                     let blk = rcv.next().await.expect("failed to advance through the blocks"); // actually advance through the blocks
                     match connection.write_all(&blk.bytes).await {
                         Ok(()) => {
-                            counter!("bytes_written", &self.metric_labels).increment(u64::from(blk.total_bytes.get()));
+                            // This metric must be written with a single context
+                            // or it will crash analysis. The simple way to
+                            // accomplish that is to attach no labels to it.
+                            counter!("bytes_written").increment(u64::from(blk.total_bytes.get()));
+
                             counter!("packets_sent", &self.metric_labels).increment(1);
                         }
                         Err(err) => {

lading/src/generator/udp.rs

@@ -189,7 +189,11 @@ impl Udp {
                     let blk = rcv.next().await.expect("failed to advance through the blocks"); // actually advance through the blocks
                     match sock.send_to(&blk.bytes, self.addr).await {
                         Ok(bytes) => {
-                            counter!("bytes_written", &self.metric_labels).increment(bytes as u64);
+                            // This metric must be written with a single context
+                            // or it will crash analysis. The simple way to
+                            // accomplish that is to attach no labels to it.
+                            counter!("bytes_written").increment(bytes as u64);
+
                             counter!("packets_sent", &self.metric_labels).increment(1);
                             connection = Some(sock);
                         }