format logs and strings inline

Jiloc · Jiloc · commit 532a906905a7 · 2025-07-21T18:39:30.000+01:00
diff --git a/clarity-serialization/src/lib.rs b/clarity-serialization/src/lib.rs
@@ -52,13 +52,7 @@ pub fn version_string(pkg_name: &str, pkg_version: &str) -> String {
     let git_tree_clean = GIT_TREE_CLEAN.unwrap_or("");
 
     format!(
-        "{} {} ({}:{}{}, {} build, {} [{}])",
-        pkg_name,
-        pkg_version,
-        &git_branch,
-        git_commit,
-        git_tree_clean,
-        BUILD_TYPE,
+        "{pkg_name} {pkg_version} ({git_branch}:{git_commit}{git_tree_clean}, {BUILD_TYPE} build {}, [{}])",
         std::env::consts::OS,
         std::env::consts::ARCH
     )
diff --git a/clarity-serialization/src/types/mod.rs b/clarity-serialization/src/types/mod.rs
@@ -1023,7 +1023,7 @@ impl Value {
             Ok(String::from_utf8(data)
                 .map_err(|_| CodecError::Expect("Non UTF-8 data in string".into()))?)
         } else {
-            error!("Value '{:?}' is not an ASCII string", &self);
+            error!("Value '{self:?}' is not an ASCII string");
             Err(CodecError::Expect("Expected ASCII string".into()))
         }
     }
@@ -1032,7 +1032,7 @@ impl Value {
         if let Value::UInt(inner) = self {
             Ok(inner)
         } else {
-            error!("Value '{:?}' is not a u128", &self);
+            error!("Value '{self:?}' is not a u128");
             Err(CodecError::Expect("Expected u128".into()))
         }
     }
@@ -1041,7 +1041,7 @@ impl Value {
         if let Value::Int(inner) = self {
             Ok(inner)
         } else {
-            error!("Value '{:?}' is not an i128", &self);
+            error!("Value '{self:?}' is not an i128");
             Err(CodecError::Expect("Expected i128".into()))
         }
     }
@@ -1052,14 +1052,13 @@ impl Value {
                 Ok(buffdata.data)
             } else {
                 error!(
-                    "Value buffer has len {}, expected {}",
-                    buffdata.data.len(),
-                    sz
+                    "Value buffer has len {}, expected {sz}",
+                    buffdata.data.len()
                 );
                 Err(CodecError::Expect("Unexpected buff length".into()))
             }
         } else {
-            error!("Value '{:?}' is not a buff", &self);
+            error!("Value '{self:?}' is not a buff");
             Err(CodecError::Expect("Expected buff".into()))
         }
     }
@@ -1068,7 +1067,7 @@ impl Value {
         if let Value::Sequence(SequenceData::List(listdata)) = self {
             Ok(listdata.data)
         } else {
-            error!("Value '{:?}' is not a list", &self);
+            error!("Value '{self:?}' is not a list");
             Err(CodecError::Expect("Expected list".into()))
         }
     }
@@ -1087,7 +1086,7 @@ impl Value {
         if let Value::Bool(b) = self {
             Ok(b)
         } else {
-            error!("Value '{:?}' is not a bool", &self);
+            error!("Value '{self:?}' is not a bool");
             Err(CodecError::Expect("Expected bool".into()))
         }
     }
@@ -1096,7 +1095,7 @@ impl Value {
         if let Value::Tuple(data) = self {
             Ok(data)
         } else {
-            error!("Value '{:?}' is not a tuple", &self);
+            error!("Value '{self:?}' is not a tuple");
             Err(CodecError::Expect("Expected tuple".into()))
         }
     }
@@ -1108,7 +1107,7 @@ impl Value {
                 None => Ok(None),
             }
         } else {
-            error!("Value '{:?}' is not an optional", &self);
+            error!("Value '{self:?}' is not an optional");
             Err(CodecError::Expect("Expected optional".into()))
         }
     }
@@ -1117,7 +1116,7 @@ impl Value {
         if let Value::Principal(p) = self {
             Ok(p)
         } else {
-            error!("Value '{:?}' is not a principal", &self);
+            error!("Value '{self:?}' is not a principal");
             Err(CodecError::Expect("Expected principal".into()))
         }
     }
@@ -1126,7 +1125,7 @@ impl Value {
         if let Value::CallableContract(t) = self {
             Ok(t)
         } else {
-            error!("Value '{:?}' is not a callable contract", &self);
+            error!("Value '{self:?}' is not a callable contract");
             Err(CodecError::Expect("Expected callable".into()))
         }
     }
@@ -1139,7 +1138,7 @@ impl Value {
                 Ok(Err(*res_data.data))
             }
         } else {
-            error!("Value '{:?}' is not a response", &self);
+            error!("Value '{self:?}' is not a response");
             Err(CodecError::Expect("Expected response".into()))
         }
     }
@@ -1153,7 +1152,7 @@ impl Value {
                 Err(CodecError::Expect("Expected ok response".into()))
             }
         } else {
-            error!("Value '{:?}' is not a response", &self);
+            error!("Value '{self:?}' is not a response");
             Err(CodecError::Expect("Expected response".into()))
         }
     }
@@ -1167,7 +1166,7 @@ impl Value {
                 Err(CodecError::Expect("Expected err response".into()))
             }
         } else {
-            error!("Value '{:?}' is not a response", &self);
+            error!("Value '{self:?}' is not a response");
             Err(CodecError::Expect("Expected response".into()))
         }
     }
diff --git a/clarity-serialization/src/types/serialization.rs b/clarity-serialization/src/types/serialization.rs
@@ -483,8 +483,7 @@ impl Value {
             if bytes_read > expect_size as u64 {
                 // this can happen due to sanitization, so its no longer indicative of a *problem* with the node.
                 debug!(
-                    "Deserialized more bytes than expected size during deserialization. Expected size = {}, bytes read = {}, type = {}",
-                    expect_size, bytes_read, expected_type,
+                    "Deserialized more bytes than expected size during deserialization. Expected size = {expect_size}, bytes read = {bytes_read}, type = {expected_type:?}"
                 );
             }
         }
@@ -1297,7 +1296,7 @@ impl StacksMessageCodec for Value {
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Value, codec_error> {
         Value::deserialize_read(fd, None, false).map_err(|e| match e {
             CodecError::Io(io_e) => codec_error::ReadError(io_e),
-            _ => codec_error::DeserializeError(format!("Failed to decode clarity value: {:?}", &e)),
+            _ => codec_error::DeserializeError(format!("Failed to decode clarity value: {e:?}")),
         })
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -1023,7 +1023,7 @@ impl Value {`
`1023`	`1023`	`Ok(String::from_utf8(data)`
`1024`	`1024`	`.map_err(\|_\| CodecError::Expect("Non UTF-8 data in string".into()))?)`
`1025`	`1025`	`} else {`
`1026`		`- error!("Value '{:?}' is not an ASCII string", &self);`
	`1026`	`+ error!("Value '{self:?}' is not an ASCII string");`
`1027`	`1027`	`Err(CodecError::Expect("Expected ASCII string".into()))`
`1028`	`1028`	`}`
`1029`	`1029`	`}`
`@@ -1032,7 +1032,7 @@ impl Value {`
`1032`	`1032`	`if let Value::UInt(inner) = self {`
`1033`	`1033`	`Ok(inner)`
`1034`	`1034`	`} else {`
`1035`		`- error!("Value '{:?}' is not a u128", &self);`
	`1035`	`+ error!("Value '{self:?}' is not a u128");`
`1036`	`1036`	`Err(CodecError::Expect("Expected u128".into()))`
`1037`	`1037`	`}`
`1038`	`1038`	`}`
`@@ -1041,7 +1041,7 @@ impl Value {`
`1041`	`1041`	`if let Value::Int(inner) = self {`
`1042`	`1042`	`Ok(inner)`
`1043`	`1043`	`} else {`
`1044`		`- error!("Value '{:?}' is not an i128", &self);`
	`1044`	`+ error!("Value '{self:?}' is not an i128");`
`1045`	`1045`	`Err(CodecError::Expect("Expected i128".into()))`
`1046`	`1046`	`}`
`1047`	`1047`	`}`
`@@ -1052,14 +1052,13 @@ impl Value {`
`1052`	`1052`	`Ok(buffdata.data)`
`1053`	`1053`	`} else {`
`1054`	`1054`	`error!(`
`1055`		`- "Value buffer has len {}, expected {}",`
`1056`		`- buffdata.data.len(),`
`1057`		`- sz`
	`1055`	`+ "Value buffer has len {}, expected {sz}",`
	`1056`	`+ buffdata.data.len()`
`1058`	`1057`	`);`
`1059`	`1058`	`Err(CodecError::Expect("Unexpected buff length".into()))`
`1060`	`1059`	`}`
`1061`	`1060`	`} else {`
`1062`		`- error!("Value '{:?}' is not a buff", &self);`
	`1061`	`+ error!("Value '{self:?}' is not a buff");`
`1063`	`1062`	`Err(CodecError::Expect("Expected buff".into()))`
`1064`	`1063`	`}`
`1065`	`1064`	`}`
`@@ -1068,7 +1067,7 @@ impl Value {`
`1068`	`1067`	`if let Value::Sequence(SequenceData::List(listdata)) = self {`
`1069`	`1068`	`Ok(listdata.data)`
`1070`	`1069`	`} else {`
`1071`		`- error!("Value '{:?}' is not a list", &self);`
	`1070`	`+ error!("Value '{self:?}' is not a list");`
`1072`	`1071`	`Err(CodecError::Expect("Expected list".into()))`
`1073`	`1072`	`}`
`1074`	`1073`	`}`
`@@ -1087,7 +1086,7 @@ impl Value {`
`1087`	`1086`	`if let Value::Bool(b) = self {`
`1088`	`1087`	`Ok(b)`
`1089`	`1088`	`} else {`
`1090`		`- error!("Value '{:?}' is not a bool", &self);`
	`1089`	`+ error!("Value '{self:?}' is not a bool");`
`1091`	`1090`	`Err(CodecError::Expect("Expected bool".into()))`
`1092`	`1091`	`}`
`1093`	`1092`	`}`
`@@ -1096,7 +1095,7 @@ impl Value {`
`1096`	`1095`	`if let Value::Tuple(data) = self {`
`1097`	`1096`	`Ok(data)`
`1098`	`1097`	`} else {`
`1099`		`- error!("Value '{:?}' is not a tuple", &self);`
	`1098`	`+ error!("Value '{self:?}' is not a tuple");`
`1100`	`1099`	`Err(CodecError::Expect("Expected tuple".into()))`
`1101`	`1100`	`}`
`1102`	`1101`	`}`
`@@ -1108,7 +1107,7 @@ impl Value {`
`1108`	`1107`	`None => Ok(None),`
`1109`	`1108`	`}`
`1110`	`1109`	`} else {`
`1111`		`- error!("Value '{:?}' is not an optional", &self);`
	`1110`	`+ error!("Value '{self:?}' is not an optional");`
`1112`	`1111`	`Err(CodecError::Expect("Expected optional".into()))`
`1113`	`1112`	`}`
`1114`	`1113`	`}`
`@@ -1117,7 +1116,7 @@ impl Value {`
`1117`	`1116`	`if let Value::Principal(p) = self {`
`1118`	`1117`	`Ok(p)`
`1119`	`1118`	`} else {`
`1120`		`- error!("Value '{:?}' is not a principal", &self);`
	`1119`	`+ error!("Value '{self:?}' is not a principal");`
`1121`	`1120`	`Err(CodecError::Expect("Expected principal".into()))`
`1122`	`1121`	`}`
`1123`	`1122`	`}`
`@@ -1126,7 +1125,7 @@ impl Value {`
`1126`	`1125`	`if let Value::CallableContract(t) = self {`
`1127`	`1126`	`Ok(t)`
`1128`	`1127`	`} else {`
`1129`		`- error!("Value '{:?}' is not a callable contract", &self);`
	`1128`	`+ error!("Value '{self:?}' is not a callable contract");`
`1130`	`1129`	`Err(CodecError::Expect("Expected callable".into()))`
`1131`	`1130`	`}`
`1132`	`1131`	`}`
`@@ -1139,7 +1138,7 @@ impl Value {`
`1139`	`1138`	`Ok(Err(*res_data.data))`
`1140`	`1139`	`}`
`1141`	`1140`	`} else {`
`1142`		`- error!("Value '{:?}' is not a response", &self);`
	`1141`	`+ error!("Value '{self:?}' is not a response");`
`1143`	`1142`	`Err(CodecError::Expect("Expected response".into()))`
`1144`	`1143`	`}`
`1145`	`1144`	`}`
`@@ -1153,7 +1152,7 @@ impl Value {`
`1153`	`1152`	`Err(CodecError::Expect("Expected ok response".into()))`
`1154`	`1153`	`}`
`1155`	`1154`	`} else {`
`1156`		`- error!("Value '{:?}' is not a response", &self);`
	`1155`	`+ error!("Value '{self:?}' is not a response");`
`1157`	`1156`	`Err(CodecError::Expect("Expected response".into()))`
`1158`	`1157`	`}`
`1159`	`1158`	`}`
`@@ -1167,7 +1166,7 @@ impl Value {`
`1167`	`1166`	`Err(CodecError::Expect("Expected err response".into()))`
`1168`	`1167`	`}`
`1169`	`1168`	`} else {`
`1170`		`- error!("Value '{:?}' is not a response", &self);`
	`1169`	`+ error!("Value '{self:?}' is not a response");`
`1171`	`1170`	`Err(CodecError::Expect("Expected response".into()))`
`1172`	`1171`	`}`
`1173`	`1172`	`}`
Original file line number	Diff line number	Diff line change
`@@ -483,8 +483,7 @@ impl Value {`
`483`	`483`	`if bytes_read > expect_size as u64 {`
`484`	`484`	`// this can happen due to sanitization, so its no longer indicative of a problem with the node.`
`485`	`485`	`debug!(`
`486`		`- "Deserialized more bytes than expected size during deserialization. Expected size = {}, bytes read = {}, type = {}",`
`487`		`- expect_size, bytes_read, expected_type,`
	`486`	`+ "Deserialized more bytes than expected size during deserialization. Expected size = {expect_size}, bytes read = {bytes_read}, type = {expected_type:?}"`
`488`	`487`	`);`
`489`	`488`	`}`
`490`	`489`	`}`
`@@ -1297,7 +1296,7 @@ impl StacksMessageCodec for Value {`
`1297`	`1296`	`fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Value, codec_error> {`
`1298`	`1297`	`Value::deserialize_read(fd, None, false).map_err(\|e\| match e {`
`1299`	`1298`	`CodecError::Io(io_e) => codec_error::ReadError(io_e),`
`1300`		`- _ => codec_error::DeserializeError(format!("Failed to decode clarity value: {:?}", &e)),`
	`1299`	`+ _ => codec_error::DeserializeError(format!("Failed to decode clarity value: {e:?}")),`
`1301`	`1300`	`})`
`1302`	`1301`	`}`
`1303`	`1302`	`}`