Applied clippy hints (lints)

src/graph/process_node.rs

@@ -1,6 +1,7 @@
 use crate::stats::call_chain::{Call, CallChain, CallDirection};
 use std::{collections::HashMap, iter};
 
+#[allow(dead_code)] // enum might have unused variants
 #[derive(Default, Debug)]
 pub enum ProcessNodeType {
     /// represents a process that is directly exposed (via an API gateway), so this is the starting point of a service-process

src/main/mermaid.rs

@@ -32,9 +32,9 @@ struct Args {
     scope: MermaidScope,
 }
 
-fn to_opt_str(s: &String) -> Option<&str> {
-    if &s[..] != EMPTY_ARG {
-        Some(s.as_str())
+fn to_opt_str(s: &str) -> Option<&str> {
+    if s != EMPTY_ARG {
+        Some(s)
     } else {
         None
     }

src/main/show_traces.rs

@@ -1,5 +1,4 @@
 use clap::Parser;
-use jaeger_stats;
 use std::path::Path;
 
 /// Show the Jaeger-traces, or a selection of jaeger-traces, as Pretty-printed JSON in UTF-8 format.

src/main/trace_analysis.rs

@@ -39,9 +39,9 @@ struct Args {
     display_call_chain: String,
 }
 
-fn to_opt_str(s: &String) -> Option<&str> {
-    if &s[..] != EMPTY_ARG {
-        Some(s.as_str())
+fn to_opt_str(s: &str) -> Option<&str> {
+    if s != EMPTY_ARG {
+        Some(s)
     } else {
         None
     }

src/mermaid/flowchart/escape_name.rs

@@ -3,8 +3,8 @@ const REPLACE_CHAR: &str = "_";
 
 /// escape a name such that it can be used as valid Mermaid label if the current input can not be used as label, otherwise None
 pub fn escape_mermaid_label(name: &str) -> Option<String> {
-    if name.contains(&TO_REPLACE) {
-        Some(name.replace(&TO_REPLACE, REPLACE_CHAR))
+    if name.contains(TO_REPLACE) {
+        Some(name.replace(TO_REPLACE, REPLACE_CHAR))
     } else {
         None
     }

src/mermaid/flowchart/mermaid.rs

@@ -1,9 +1,6 @@
 use super::{
-    super::service_oper_graph::LinkType,
-    basic_node::MermaidBasicNode,
-    link::MermaidLink,
-    node::MermaidNode,
-    sub_graph::MermaidSubGraph,
+    super::service_oper_graph::LinkType, basic_node::MermaidBasicNode, link::MermaidLink,
+    node::MermaidNode, sub_graph::MermaidSubGraph,
 };
 
 pub struct Mermaid {

src/mermaid/service_oper_graph/compact_link.rs

@@ -66,6 +66,6 @@ impl<'a> CompactLink<'a> {
         self.0
             .entry(key)
             .and_modify(|value| value.merge(c_value))
-            .or_insert(c_value.clone());
+            .or_insert(c_value);
     }
 }

src/mermaid/service_oper_graph/edge_value_selector.rs

@@ -5,7 +5,7 @@ pub type EdgeValueSelector = fn(Option<&CallDescriptorStats>) -> Option<f64>;
 
 pub fn edge_value_to_selector(edge_value: EdgeValue) -> EdgeValueSelector {
     match edge_value {
-        EdgeValue::Count => |cds| cds.and_then(|ips| Some(ips.count as f64)),
+        EdgeValue::Count => |cds| cds.map(|ips| ips.count as f64),
         EdgeValue::AvgMillis => |cds| cds.and_then(|ips| ips.avg_duration_millis.get_value()),
         EdgeValue::P75Millis => |cds| cds.and_then(|ips| ips.p75_millis.get_value()),
         EdgeValue::P90Millis => |cds| cds.and_then(|ips| ips.p90_millis.get_value()),

src/mermaid/service_oper_graph/mod.rs

@@ -7,10 +7,10 @@ mod node_select;
 mod operation;
 mod position;
 mod service;
-mod service_oper_graph;
 mod service_oper_type;
+mod sog;
 
 pub use link_type::LinkType;
 pub use position::Position;
-pub use service_oper_graph::ServiceOperGraph;
 pub use service_oper_type::ServiceOperationType;
+pub use sog::ServiceOperGraph;

src/mermaid/service_oper_graph/node_select.rs

@@ -7,17 +7,23 @@ pub type NodeSelector = fn(&Service) -> bool;
 pub fn scope_to_node_selector(scope: MermaidScope) -> NodeSelector {
     match scope {
         MermaidScope::Full => |_service| true,
-        MermaidScope::Centered => |service| match service.position {
-            super::Position::Center | Position::InboundCenter | Position::OutboundCenter => true,
-            _ => false,
+        MermaidScope::Centered => |service| {
+            matches!(
+                service.position,
+                |super::Position::Center| Position::InboundCenter | Position::OutboundCenter,
+            )
         },
-        MermaidScope::Inbound => |service| match service.position {
-            super::Position::Center | super::Position::Inbound | Position::InboundCenter => true,
-            _ => false,
+        MermaidScope::Inbound => |service| {
+            matches!(
+                service.position,
+                |super::Position::Center| super::Position::Inbound | Position::InboundCenter,
+            )
         },
-        MermaidScope::Outbound => |service| match service.position {
-            super::Position::Center | super::Position::Outbound | Position::OutboundCenter => true,
-            _ => false,
+        MermaidScope::Outbound => |service| {
+            matches!(
+                service.position,
+                |super::Position::Center| super::Position::Outbound | Position::OutboundCenter,
+            )
         },
     }
 }

src/mermaid/service_oper_graph/position.rs

@@ -10,6 +10,7 @@ use crate::stats::call_chain::Call;
 /// These output formats are needed:
 ///   * to prevent that views grow to large to be visible (easy zooming in on the relevant parts)
 ///   * to allow for generation of tailored diagrams for inclusion in architect documentation.
+#[allow(dead_code)] // might contain unused variants
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum Position {
     Unknown, // or do not change position
@@ -31,7 +32,7 @@ impl Position {
             (true, true) => (Position::Center, Position::Center),
             (true, false) => (Position::Center, Position::OutboundCenter),
             (false, true) => (Position::InboundCenter, Position::Center),
-            (false, false) => (default_pos.clone(), default_pos),
+            (false, false) => (default_pos, default_pos),
         }
     }
 

src/mermaid/service_oper_graph/service.rs

@@ -5,10 +5,10 @@ use super::{
     node_select::NodeSelector,
     operation::Operation,
     position::Position,
-    service_oper_graph::ServiceOperGraph,
     service_oper_type::ServiceOperationType,
+    sog::ServiceOperGraph,
 };
-use crate::{stats::call_chain::CallDirection};
+use crate::stats::call_chain::CallDirection;
 
 #[derive(Debug)]
 pub struct Service {

src/mermaid/service_oper_graph/service_oper_graph.rs → src/mermaid/service_oper_graph/sog.rs

@@ -41,17 +41,14 @@ impl ServiceOperGraph {
     /// find the Service-Operation combination, and return the index-pair as a Location in the ServiceOperGraph or None
     fn get_service_operation_idx(&self, call: &Call) -> Option<Loc> {
         match self.get_service_idx(&call.service) {
-            Some(serv_idx) => match self.0[serv_idx]
+            Some(serv_idx) => self.0[serv_idx]
                 .operations
                 .iter()
                 .position(|o| o.oper == call.operation)
-            {
-                Some(oper_idx) => Some(Loc {
+                .map(|oper_idx| Loc {
                     service_idx: serv_idx,
                     oper_idx,
                 }),
-                None => None,
-            },
             None => None,
         }
     }
@@ -96,9 +93,9 @@ impl ServiceOperGraph {
         default_pos: Position,
     ) {
         // determine the from and to and add them if they do not exist
-        let (from_pos, to_pos) = Position::find_positions(&from, &to, service, default_pos);
-        let from = self.get_create_service_operation_idx(&from, from_pos);
-        let to = self.get_create_service_operation_idx(&to, to_pos);
+        let (from_pos, to_pos) = Position::find_positions(from, to, service, default_pos);
+        let from = self.get_create_service_operation_idx(from, from_pos);
+        let to = self.get_create_service_operation_idx(to, to_pos);
         // Add new link or update the existing link with the data
         self.0[from.service_idx].operations[from.oper_idx].upsert_link(to, data)
     }

src/mermaid/trace_data.rs

@@ -38,8 +38,9 @@ pub struct TraceData {
 }
 
 impl TraceData {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
-        full_key: &String,
+        full_key: &str,
         rooted: bool,
         is_leaf: bool,
         count: u64,
@@ -49,7 +50,7 @@ impl TraceData {
         p95_millis: Option<f64>,
         p99_millis: Option<f64>,
     ) -> Self {
-        let full_key = full_key.clone();
+        let full_key = full_key.to_owned();
         let trace_path = CChainStatsKey::parse(&full_key).unwrap_or_else(|err| {
             panic!("Failed to parse CChainKey: '{full_key}'\nGot error '{err:?}'")
         });

src/mermaid/trace_forrest.rs

@@ -32,8 +32,7 @@ impl<'a> TraceForrest<'a> {
         self.0
             .iter()
             .enumerate()
-            .filter(|(_, tn)| tn.service == call.service && tn.operation == call.operation)
-            .next()
+            .find(|(_, tn)| tn.service == call.service && tn.operation == call.operation)
             .map(|(idx, _tn)| idx)
     }
 

src/mermaid/trace_paths.rs

@@ -72,7 +72,7 @@ impl TracePaths {
                         let call_chain = &ccd.trace_path.call_chain;
                         if call_chain.len() >= 2 {
                             let skip = call_chain.len() - 2;
-                            let mut cc = call_chain.into_iter().skip(skip);
+                            let mut cc = call_chain.iter().skip(skip);
                             let from = cc.next().unwrap();
                             let to = cc.next().unwrap();
 
@@ -98,7 +98,7 @@ impl TracePaths {
                     };
                     sog
                         // TODO: remove the clone operations (and fix downstream)
-                        .add_connection(&from, &to, edge_data, service, default_pos);
+                        .add_connection(from, to, edge_data, service, default_pos);
                     sog
                 },
             );

src/mermaid/tt_utils.rs

@@ -1,15 +1,14 @@
 use super::service_oper_graph::{LinkType, ServiceOperGraph};
 use crate::stats::CChainStatsKey;
-use regex;
 
 // split a service out of a service-oper string by spitting at the '/' (or returning the full str if no '/' is present)
 pub fn split_service(service_oper: &str) -> &str {
-    service_oper.split("/").next().unwrap()
+    service_oper.split('/').next().unwrap()
 }
 
 // split a a service-oper string by spitting at the '/' and returnning the tuple `(service, Some(operation))`  (or returning the `(Service, None)`` if no '/' is present)
 pub fn split_service_operation(service_oper: &str) -> (&str, Option<&str>) {
-    let mut parts = service_oper.split("/");
+    let mut parts = service_oper.split('/');
     let service = parts.next().unwrap();
     let oper_opt = parts.next();
     (service, oper_opt)

src/processed/mod.rs

@@ -5,6 +5,6 @@ mod trace;
 mod unify_operation;
 
 pub use self::{
-    span::{set_max_log_msg_length, Span, Spans},
+    span::{Span, Spans},
     trace::{extract_traces, Trace},
 };

src/raw/file_tracker.rs

@@ -17,10 +17,10 @@ impl FileTracker {
             !self.files.is_empty(),
             "Add at least one filename before getting an index"
         );
-        self.files.len() as usize - 1
+        self.files.len() - 1
     }
 
-    #[allow(dead_code)]    
+    #[allow(dead_code)]
     pub fn get_file_name(&self, idx: usize) -> String {
         assert!(idx < self.files.len(), "Index out of bounds");
         self.files[idx].to_owned()

src/raw/jaeger.rs

@@ -138,8 +138,7 @@ pub struct JaegerTrace {
 impl JaegerTrace {
     /// Build a JaegerTrace with a single JaegerItem in it (so a single TraceId)
     pub fn new(ji: JaegerItem) -> Self {
-        let mut data = Vec::with_capacity(1);
-        data.push(ji);
+        let data = vec![ji];
 
         JaegerTrace {
             data,

src/raw/read_folder.rs

@@ -106,12 +106,11 @@ fn extract_jaeger_traces(jt: JaegerTrace) -> Vec<JaegerTrace> {
         Some(err) if err.is_empty() => (),
         Some(err) => {
             // TODO:  send this to the report file instead of just console
-            println!("Discovered errors: {err:?}");
-            ()
+            println!("Discovered errors: {err:?}")
         }
     };
 
-    jt.data.into_iter().map(|ji| JaegerTrace::new(ji)).collect()
+    jt.data.into_iter().map(JaegerTrace::new).collect()
 }
 
 /// read a series of raw Jaeger-traces from a file or a folder

src/raw/write.rs

@@ -1,19 +1,13 @@
 use super::JaegerTrace;
 use crate::utils;
-use serde_json;
-use std::{
-    collections::HashSet,
-    fs::File,
-    io::Write,
-    path::{Path, PathBuf},
-};
+use std::{collections::HashSet, fs::File, io::Write, path::Path};
 
 /// write a single trace as a pretty-printed json to a folder given in 'path' and use the trace_id as the file_base.
-fn write_trace(trace_folder: &PathBuf, jt: &JaegerTrace) {
+fn write_trace(trace_folder: &Path, jt: &JaegerTrace) {
     assert!(!jt.data.is_empty(), "Can not write an empty JaegerTrace");
     let file_path = {
         let file_name = format!("{}.json", jt.data[0].traceID);
-        let mut trace_folder = trace_folder.clone();
+        let mut trace_folder = trace_folder.to_path_buf();
         trace_folder.push(file_name);
         trace_folder.into_os_string()
     };
@@ -47,7 +41,7 @@ fn write_trace(trace_folder: &PathBuf, jt: &JaegerTrace) {
 pub fn write_traces(folder: &Path, traces: Vec<JaegerTrace>, trace_ids: &str) -> u32 {
     let trace_ids: HashSet<String> = trace_ids
         .split(',')
-        .filter(|s| *s != "") // drop the empty strings
+        .filter(|s| !s.is_empty()) // drop the empty strings
         .map(|s| s.to_owned())
         .collect();
     let selected = |jt: &&JaegerTrace| {

src/stats/call_chain/cchain_cache.rs

@@ -121,15 +121,12 @@ impl CChainEndPointCache {
 impl Drop for CChainEndPointCache {
     /// write all dirty cache entries to a file
     fn drop(&mut self) {
-        mem::take(&mut self.cache)
-            .into_iter()
-            .for_each(|(k, v)| match v {
-                Some(v) => {
-                    if v.is_dirty() {
-                        v.write_call_chain(self.path.clone(), &k);
-                    }
+        mem::take(&mut self.cache).into_iter().for_each(|(k, v)| {
+            if let Some(v) = v {
+                if v.is_dirty() {
+                    v.write_call_chain(self.path.clone(), &k);
                 }
-                None => (),
-            });
+            }
+        });
     }
 }

src/stats/call_chain/cchain_stats.rs

@@ -56,7 +56,7 @@ impl CChainStatsKey {
             .map(|call| call.get_process_method())
             .collect::<Vec<_>>()
             .join(", ");
-        if key.is_empty() && self.call_chain.len() > 0 {
+        if key.is_empty() && !self.call_chain.is_empty() {
             // if string is empty but call-chain is not we show the first call (the api-gateway call that apparantly is not marked as inbound)
             self.call_chain[0].get_process_method()
         } else {

src/stats/call_chain/file.rs

@@ -41,7 +41,7 @@ pub fn read_cchain_file(path: &Path) -> Result<EndPointCChains, Box<dyn Error>>
 }
 
 /// the label shows whether cached processes are in the call-chain and if so returns a suffix to represent it.
-pub fn caching_process_label(caching_process: &Vec<String>, call_chain: &CallChain) -> String {
+pub fn caching_process_label(caching_process: &[String], call_chain: &CallChain) -> String {
     if caching_process.is_empty() {
         return "".to_owned();
     }

src/stats/operation_stats.rs

@@ -58,7 +58,7 @@ impl OperationStats {
         idx: usize,
         span: &Span,
         spans: &Spans,
-        caching_process: &Vec<String>,
+        caching_process: &[String],
         root_call: &str,
     ) {
         match &span.span_kind {
@@ -90,7 +90,7 @@ impl OperationStats {
         self.operation
             .0
             .entry(method.to_owned())
-            .and_modify(|oper_stat| update_proc_oper_value(oper_stat))
+            .and_modify(update_proc_oper_value)
             .or_insert_with(|| {
                 let mut oper_stat = ProcOperStatsValue::default();
                 update_proc_oper_value(&mut oper_stat);
@@ -133,7 +133,7 @@ impl OperationStats {
             .0
             .entry(ps_key)
             // next part could be made more dry via an update-closure
-            .and_modify(|ps| update_ps_val(ps))
+            .and_modify(update_ps_val)
             .or_insert_with(|| {
                 let mut ps = CChainStatsValue::new(depth, looped, rooted);
                 update_ps_val(&mut ps);