From 84dc8554eb12f5dcac0d42ab2a9ddbda0538ae4d Mon Sep 17 00:00:00 2001 From: Sebastian Scholz Date: Wed, 17 Sep 2025 10:56:54 +0200 Subject: [PATCH 1/2] Allow to disable logging --- Cargo.toml | 4 +++- src/codec/rtu/client.rs | 14 ++++++++------ src/codec/rtu/mod.rs | 2 ++ src/codec/rtu/server.rs | 15 +++++++++------ src/codec/tcp/client.rs | 15 ++++++++------- src/codec/tcp/mod.rs | 14 +++++++++----- src/codec/tcp/server.rs | 29 ++++++++++++++++------------- 7 files changed, 55 insertions(+), 38 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 0e8b2da..1f8accb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -22,9 +22,11 @@ tcp = [] rtu = [] std = ["byteorder/std"] defmt = ["dep:defmt"] +# Enable decoding error logging. +log = ["dep:log"] [dependencies] -log = { version = "0.4.28" } +log = { version = "0.4.28", optional = true } byteorder = { version = "1.5.0", default-features = false } [target.'cfg(target_os = "none")'.dependencies] diff --git a/src/codec/rtu/client.rs b/src/codec/rtu/client.rs index 71b6e51..fe66ba9 100644 --- a/src/codec/rtu/client.rs +++ b/src/codec/rtu/client.rs @@ -35,14 +35,16 @@ pub fn decode_response(buf: &[u8]) -> Result>> { // to transmission errors, because the frame's bytes // have already been verified with the CRC. - ExceptionResponse::try_from(pdu) + let response = ExceptionResponse::try_from(pdu) .map(|er| ResponsePdu(Err(er))) .or_else(|_| Response::try_from(pdu).map(|r| ResponsePdu(Ok(r)))) - .map(|pdu| Some(ResponseAdu { hdr, pdu })) - .inspect_err(|&err| { - // Unrecoverable error - log::error!("Failed to decode Response PDU: {err}"); - }) + .map(|pdu| Some(ResponseAdu { hdr, pdu })); + #[cfg(feature = "log")] + response.inspect_err(|&err| { + // Unrecoverable error + log::error!("Failed to decode Response PDU: {err}"); + }); + response }) .map_err(|_| { // Decoding the transport frame is non-destructive and must diff --git a/src/codec/rtu/mod.rs b/src/codec/rtu/mod.rs index 709b537..468789c 100644 --- a/src/codec/rtu/mod.rs +++ b/src/codec/rtu/mod.rs @@ -72,12 +72,14 @@ pub fn decode( }) .or_else(|err| { if drop_cnt + 1 >= MAX_FRAME_LEN { + #[cfg(feature = "log")] log::error!( "Giving up to decode frame after dropping {drop_cnt} byte(s): {:X?}", &buf[0..drop_cnt] ); return Err(err); } + #[cfg(feature = "log")] log::warn!( "Failed to decode {} frame: {err}", match decoder_type { diff --git a/src/codec/rtu/server.rs b/src/codec/rtu/server.rs index 04f2ed3..278ff6f 100644 --- a/src/codec/rtu/server.rs +++ b/src/codec/rtu/server.rs @@ -18,13 +18,16 @@ pub fn decode_request(buf: &[u8]) -> Result>> { // Decoding of the PDU should are unlikely to fail due // to transmission errors, because the frame's bytes // have already been verified with the CRC. - Request::try_from(pdu) + let request = Request::try_from(pdu) .map(RequestPdu) - .map(|pdu| Some(RequestAdu { hdr, pdu })) - .inspect_err(|&err| { - // Unrecoverable error - log::error!("Failed to decode request PDU: {err}"); - }) + .map(|pdu| Some(RequestAdu { hdr, pdu })); + + #[cfg(feature = "log")] + request.inspect_err(|&err| { + // Unrecoverable error + log::error!("Failed to decode request PDU: {err}"); + }); + request }) .map_err(|_| { // Decoding the transport frame is non-destructive and must diff --git a/src/codec/tcp/client.rs b/src/codec/tcp/client.rs index 64a94fa..6f633b5 100644 --- a/src/codec/tcp/client.rs +++ b/src/codec/tcp/client.rs @@ -46,15 +46,16 @@ pub fn decode_response(buf: &[u8]) -> Result>> { // Decoding of the PDU should are unlikely to fail due // to transmission errors, because the frame's bytes // have already been verified with the CRC. - - ExceptionResponse::try_from(pdu) + let response = ExceptionResponse::try_from(pdu) .map(|er| ResponsePdu(Err(er))) .or_else(|_| Response::try_from(pdu).map(|r| ResponsePdu(Ok(r)))) - .map(|pdu| Some(ResponseAdu { hdr, pdu })) - .inspect_err(|&err| { - // Unrecoverable error - log::error!("Failed to decode Response PDU: {err}"); - }) + .map(|pdu| Some(ResponseAdu { hdr, pdu })); + #[cfg(feature = "log")] + response.inspect_err(|&err| { + // Unrecoverable error + log::error!("Failed to decode Response PDU: {err}"); + }); + response }) .map_err(|_| { // Decoding the transport frame is non-destructive and must diff --git a/src/codec/tcp/mod.rs b/src/codec/tcp/mod.rs index 92da306..2840beb 100644 --- a/src/codec/tcp/mod.rs +++ b/src/codec/tcp/mod.rs @@ -75,18 +75,22 @@ pub fn decode( } }) .or_else(|err| { - let pdu_type = match decoder_type { - Request => "request", - Response => "response", - }; if drop_cnt + 1 >= MAX_FRAME_LEN { + #[cfg(feature = "log")] log::error!( "Giving up to decode frame after dropping {drop_cnt} byte(s): {:X?}", &buf[0..drop_cnt] ); return Err(err); } - log::warn!("Failed to decode {pdu_type} frame: {err}"); + #[cfg(feature = "log")] + log::warn!( + "Failed to decode {pdu_type} frame: {err}", + pdu_type = match decoder_type { + Request => "request", + Response => "response", + } + ); drop_cnt += 1; retry = true; Ok(None) diff --git a/src/codec/tcp/server.rs b/src/codec/tcp/server.rs index 8d71644..7726c2a 100644 --- a/src/codec/tcp/server.rs +++ b/src/codec/tcp/server.rs @@ -25,13 +25,15 @@ pub fn decode_request(buf: &[u8]) -> Result>> { // Decoding of the PDU should are unlikely to fail due // to transmission errors, because the frame's bytes // have already been verified at the TCP level. - Request::try_from(pdu) + let request = Request::try_from(pdu) .map(RequestPdu) - .map(|pdu| Some(RequestAdu { hdr, pdu })) - .inspect_err(|&err| { - // Unrecoverable error - log::error!("Failed to decode request PDU: {err}"); - }) + .map(|pdu| Some(RequestAdu { hdr, pdu })); + #[cfg(feature = "log")] + request.inspect_err(|&err| { + // Unrecoverable error + log::error!("Failed to decode request PDU: {err}"); + }); + request } // Decode a TCP response @@ -56,16 +58,17 @@ pub fn decode_response(buf: &[u8]) -> Result>> { // Decoding of the PDU should are unlikely to fail due // to transmission errors, because the frame's bytes // have already been verified at the TCP level. - - Response::try_from(pdu) + let response = Response::try_from(pdu) .map(Ok) .or_else(|_| ExceptionResponse::try_from(pdu).map(Err)) .map(ResponsePdu) - .map(|pdu| Some(ResponseAdu { hdr, pdu })) - .inspect_err(|&err| { - // Unrecoverable error - log::error!("Failed to decode response PDU: {err}"); - }) + .map(|pdu| Some(ResponseAdu { hdr, pdu })); + #[cfg(feature = "log")] + response.inspect_err(|&err| { + // Unrecoverable error + log::error!("Failed to decode response PDU: {err}"); + }); + response }) .map_err(|_| { // Decoding the transport frame is non-destructive and must From b24deb62ecb3d8f171aa447820ac429d8cc1982f Mon Sep 17 00:00:00 2001 From: Sebastian Scholz Date: Wed, 17 Sep 2025 11:04:50 +0200 Subject: [PATCH 2/2] Use let Err() instead of inspect_err --- src/codec/rtu/client.rs | 6 +++--- src/codec/rtu/server.rs | 6 +++--- src/codec/tcp/client.rs | 6 +++--- src/codec/tcp/server.rs | 12 ++++++------ 4 files changed, 15 insertions(+), 15 deletions(-) diff --git a/src/codec/rtu/client.rs b/src/codec/rtu/client.rs index fe66ba9..b0f840b 100644 --- a/src/codec/rtu/client.rs +++ b/src/codec/rtu/client.rs @@ -40,10 +40,10 @@ pub fn decode_response(buf: &[u8]) -> Result>> { .or_else(|_| Response::try_from(pdu).map(|r| ResponsePdu(Ok(r)))) .map(|pdu| Some(ResponseAdu { hdr, pdu })); #[cfg(feature = "log")] - response.inspect_err(|&err| { + if let Err(error) = response { // Unrecoverable error - log::error!("Failed to decode Response PDU: {err}"); - }); + log::error!("Failed to decode Response PDU: {error}"); + } response }) .map_err(|_| { diff --git a/src/codec/rtu/server.rs b/src/codec/rtu/server.rs index 278ff6f..825df49 100644 --- a/src/codec/rtu/server.rs +++ b/src/codec/rtu/server.rs @@ -23,10 +23,10 @@ pub fn decode_request(buf: &[u8]) -> Result>> { .map(|pdu| Some(RequestAdu { hdr, pdu })); #[cfg(feature = "log")] - request.inspect_err(|&err| { + if let Err(error) = request { // Unrecoverable error - log::error!("Failed to decode request PDU: {err}"); - }); + log::error!("Failed to decode request PDU: {error}"); + } request }) .map_err(|_| { diff --git a/src/codec/tcp/client.rs b/src/codec/tcp/client.rs index 6f633b5..d8f91f9 100644 --- a/src/codec/tcp/client.rs +++ b/src/codec/tcp/client.rs @@ -51,10 +51,10 @@ pub fn decode_response(buf: &[u8]) -> Result>> { .or_else(|_| Response::try_from(pdu).map(|r| ResponsePdu(Ok(r)))) .map(|pdu| Some(ResponseAdu { hdr, pdu })); #[cfg(feature = "log")] - response.inspect_err(|&err| { + if let Err(error) = response { // Unrecoverable error - log::error!("Failed to decode Response PDU: {err}"); - }); + log::error!("Failed to decode Response PDU: {error}"); + } response }) .map_err(|_| { diff --git a/src/codec/tcp/server.rs b/src/codec/tcp/server.rs index 7726c2a..157773c 100644 --- a/src/codec/tcp/server.rs +++ b/src/codec/tcp/server.rs @@ -29,10 +29,10 @@ pub fn decode_request(buf: &[u8]) -> Result>> { .map(RequestPdu) .map(|pdu| Some(RequestAdu { hdr, pdu })); #[cfg(feature = "log")] - request.inspect_err(|&err| { + if let Err(error) = request { // Unrecoverable error - log::error!("Failed to decode request PDU: {err}"); - }); + log::error!("Failed to decode request PDU: {error}"); + } request } @@ -64,10 +64,10 @@ pub fn decode_response(buf: &[u8]) -> Result>> { .map(ResponsePdu) .map(|pdu| Some(ResponseAdu { hdr, pdu })); #[cfg(feature = "log")] - response.inspect_err(|&err| { + if let Err(error) = response { // Unrecoverable error - log::error!("Failed to decode response PDU: {err}"); - }); + log::error!("Failed to decode response PDU: {error}"); + } response }) .map_err(|_| {