ekump/APMSP-1827 add warnings for panics

alloc/src/lib.rs

@@ -2,6 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #![cfg_attr(not(test), no_std)]
+#![cfg_attr(not(test), deny(clippy::panic))]
+#![cfg_attr(not(test), deny(clippy::unwrap_used))]
+#![cfg_attr(not(test), deny(clippy::expect_used))]
+#![cfg_attr(not(test), deny(clippy::todo))]
+#![cfg_attr(not(test), deny(clippy::unimplemented))]
 
 mod chain;
 mod linear;

crashtracker-ffi/src/lib.rs

@@ -1,6 +1,12 @@
 // Copyright 2024-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
+#![cfg_attr(not(test), deny(clippy::panic))]
+#![cfg_attr(not(test), deny(clippy::unwrap_used))]
+#![cfg_attr(not(test), deny(clippy::expect_used))]
+#![cfg_attr(not(test), deny(clippy::todo))]
+#![cfg_attr(not(test), deny(clippy::unimplemented))]
+
 #[cfg(all(unix, feature = "collector"))]
 mod collector;
 mod crash_info;

crashtracker/src/collector/crash_handler.rs

@@ -76,10 +76,12 @@ struct PreparedExecve {
 impl PreparedExecve {
     fn new(config: &CrashtrackerReceiverConfig) -> Self {
         // Allocate and store binary path
+        #[allow(clippy::expect_used)]
         let binary_path = CString::new(config.path_to_receiver_binary.as_str())
             .expect("Failed to convert binary path to CString");
 
         // Allocate and store arguments
+        #[allow(clippy::expect_used)]
         let args_cstrings: Vec<CString> = config
             .args
             .iter()
@@ -97,6 +99,7 @@ impl PreparedExecve {
             .iter()
             .map(|(key, value)| {
                 let env_str = format!("{key}={value}");
+                #[allow(clippy::expect_used)]
                 CString::new(env_str).expect("Failed to convert environment variable to CString")
             })
             .collect();
@@ -188,6 +191,7 @@ fn run_receiver_child(uds_parent: RawFd, uds_child: RawFd, stderr: RawFd, stdout
     // allocations in the signal handler.
     let receiver_args = RECEIVER_ARGS.load(SeqCst);
     let (binary_path, args_ptrs, env_vars_ptrs) = unsafe {
+        #[allow(clippy::expect_used)]
         let receiver_args = receiver_args.as_ref().expect("No receiver arguments");
         (
             &receiver_args.binary_path,

crashtracker/src/collector/emitters.rs

@@ -48,6 +48,7 @@ unsafe fn emit_backtrace_by_frames(
         if resolve_frames == StacktraceCollection::EnabledWithInprocessSymbols {
             backtrace::resolve_frame_unsynchronized(frame, |symbol| {
                 write!(w, "{{").unwrap();
+                #[allow(clippy::unwrap_used)]
                 emit_absolute_addresses(w, frame).unwrap();
                 if let Some(column) = symbol.colno() {
                     write!(w, ", \"column\": {column}").unwrap();
@@ -64,17 +65,21 @@ unsafe fn emit_backtrace_by_frames(
                 }
                 writeln!(w, "}}").unwrap();
                 // Flush eagerly to ensure that each frame gets emitted even if the next one fails
+                #[allow(clippy::unwrap_used)]
                 w.flush().unwrap();
             });
         } else {
             write!(w, "{{").unwrap();
+            #[allow(clippy::unwrap_used)]
             emit_absolute_addresses(w, frame).unwrap();
             writeln!(w, "}}").unwrap();
             // Flush eagerly to ensure that each frame gets emitted even if the next one fails
+            #[allow(clippy::unwrap_used)]
             w.flush().unwrap();
         }
         true // keep going to the next frame
     });
+    #[allow(clippy::unwrap_used)]
     writeln!(w, "{DD_CRASHTRACK_END_STACKTRACE}").unwrap();
     w.flush()?;
     Ok(())

crashtracker/src/lib.rs

@@ -44,6 +44,12 @@
 //! Handling of forks
 //! Safety issues
 
+#![cfg_attr(not(test), deny(clippy::panic))]
+#![cfg_attr(not(test), deny(clippy::unwrap_used))]
+#![cfg_attr(not(test), deny(clippy::expect_used))]
+#![cfg_attr(not(test), deny(clippy::todo))]
+#![cfg_attr(not(test), deny(clippy::unimplemented))]
+
 #[cfg(all(unix, feature = "collector"))]
 mod collector;
 mod crash_info;

data-pipeline-ffi/src/lib.rs

@@ -1,5 +1,10 @@
 // Copyright 2024-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
+#![cfg_attr(not(test), deny(clippy::panic))]
+#![cfg_attr(not(test), deny(clippy::unwrap_used))]
+#![cfg_attr(not(test), deny(clippy::expect_used))]
+#![cfg_attr(not(test), deny(clippy::todo))]
+#![cfg_attr(not(test), deny(clippy::unimplemented))]
 
 mod error;
 mod response;

data-pipeline/src/lib.rs

@@ -1,6 +1,10 @@
 // Copyright 2024-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
-#![deny(missing_docs)]
+#![cfg_attr(not(test), deny(clippy::panic))]
+#![cfg_attr(not(test), deny(clippy::unwrap_used))]
+#![cfg_attr(not(test), deny(clippy::expect_used))]
+#![cfg_attr(not(test), deny(clippy::todo))]
+#![cfg_attr(not(test), deny(clippy::unimplemented))]
 
 //! TraceExporter provides a minimum viable product (MVP) to send traces to agents. The aim of the
 //! project at this state is to provide a basic API in order to test its viability and integration

data-pipeline/src/stats_exporter.rs

@@ -121,6 +121,7 @@ impl StatsExporter {
         encode_stats_payload(
             self.meta.borrow(),
             sequence,
+            #[allow(clippy::unwrap_used)]
             self.concentrator
                 .lock()
                 .unwrap()

data-pipeline/src/telemetry/mod.rs

@@ -80,6 +80,7 @@ impl TelemetryClientBuilder {
 
     /// Builds the telemetry client.
     pub async fn build(self) -> Result<TelemetryClient, TelemetryError> {
+        #[allow(clippy::unwrap_used)]
         let mut builder = TelemetryWorkerBuilder::new_fetch_host(
             self.service_name.unwrap(),
             self.language.unwrap(),

data-pipeline/src/trace_exporter/error.rs

@@ -95,6 +95,7 @@ impl NetworkError {
 
 impl Display for NetworkError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        #[allow(clippy::unwrap_used)]
         std::fmt::Display::fmt(self.source().unwrap(), f)
     }
 }

data-pipeline/src/trace_exporter/mod.rs

@@ -84,6 +84,8 @@ impl TraceExporterOutputFormat {
     fn add_query(&self, url: &Uri, query: &str) -> Uri {
         let url = format!("{}?{}", url, query);
 
+        // TODO: Properly handle non-OK states to prevent possible panics (APMSP-18190).
+        #[allow(clippy::expect_used)]
         Uri::from_str(&url).expect("Failed to create Uri from string")
     }
 }
@@ -96,6 +98,8 @@ impl TraceExporterOutputFormat {
 /// * `path` - The path to be added to the URL.
 fn add_path(url: &Uri, path: &str) -> Uri {
     let p_and_q = url.path_and_query();
+
+    #[allow(clippy::unwrap_used)]
     let new_p_and_q = match p_and_q {
         Some(pq) => {
             let p = pq.path();
@@ -111,6 +115,7 @@ fn add_path(url: &Uri, path: &str) -> Uri {
     let mut parts = url.clone().into_parts();
     parts.path_and_query = Some(new_p_and_q);
     // TODO: Properly handle non-OK states to prevent possible panics (APMSP-18190).
+    #[allow(clippy::unwrap_used)]
     Uri::from_parts(parts).unwrap()
 }
 
@@ -356,7 +361,9 @@ impl TraceExporter {
             self.runtime.block_on(async {
                 cancellation_token.cancel();
             });
+            #[allow(clippy::unwrap_used)]
             let bucket_size = stats_concentrator.lock().unwrap().get_bucket_size();
+
             self.client_side_stats
                 .store(Arc::new(StatsComputationStatus::DisabledByAgent {
                     bucket_size,
@@ -403,7 +410,9 @@ impl TraceExporter {
                         exporter_handle: _,
                     } => {
                         if agent_info.info.client_drop_p0s.is_some_and(|v| v) {
+                            #[allow(clippy::unwrap_used)]
                             let mut concentrator = stats_concentrator.lock().unwrap();
+
                             concentrator.set_span_kinds(
                                 agent_info
                                     .info
@@ -459,6 +468,8 @@ impl TraceExporter {
             req_builder = req_builder
                 .header("Content-type", "application/msgpack")
                 .header("X-Datadog-Trace-Count", trace_count.to_string().as_str());
+
+            #[allow(clippy::unwrap_used)]
             let req = req_builder
                 .body(Body::from(Bytes::copy_from_slice(data)))
                 // TODO: Properly handle non-OK states to prevent possible panics (APMSP-18190).
@@ -474,6 +485,7 @@ impl TraceExporter {
                     if !response_status.is_success() {
                         // TODO: Properly handle non-OK states to prevent possible panics
                         // (APMSP-18190).
+                        #[allow(clippy::unwrap_used)]
                         let body_bytes = response.into_body().collect().await.unwrap().to_bytes();
                         let response_body =
                             String::from_utf8(body_bytes.to_vec()).unwrap_or_default();
@@ -555,7 +567,9 @@ impl TraceExporter {
             exporter_handle: _,
         } = &**self.client_side_stats.load()
         {
+            #[allow(clippy::unwrap_used)]
             let mut stats_concentrator = stats_concentrator.lock().unwrap();
+
             match collection {
                 TraceCollection::TraceChunk(traces) => {
                     let spans = traces.iter().flat_map(|trace| trace.iter());

ddcommon-ffi/src/endpoint.rs

@@ -30,6 +30,7 @@ pub extern "C" fn ddog_endpoint_from_filename(filename: crate::CharSlice) -> Opt
 pub extern "C" fn ddog_endpoint_from_api_key(api_key: crate::CharSlice) -> Box<Endpoint> {
     let mut parts = Parts::default();
     parts.authority = Some(Authority::from_static("datadoghq.com"));
+    #[allow(clippy::unwrap_used)]
     Box::new(Endpoint {
         url: hyper::Uri::from_parts(parts).unwrap(),
         api_key: Some(api_key.to_utf8_lossy().to_string().into()),
@@ -52,6 +53,7 @@ pub extern "C" fn ddog_endpoint_from_api_key_and_site(
         Err(e) => return Some(Box::new(Error::from(e.to_string()))),
     });
     *endpoint = Box::into_raw(Box::new(Endpoint {
+        #[allow(clippy::unwrap_used)]
         url: hyper::Uri::from_parts(parts).unwrap(),
         api_key: Some(api_key.to_utf8_lossy().to_string().into()),
         ..Default::default()

ddcommon-ffi/src/lib.rs

@@ -1,5 +1,10 @@
 // Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
+#![cfg_attr(not(test), deny(clippy::panic))]
+#![cfg_attr(not(test), deny(clippy::unwrap_used))]
+#![cfg_attr(not(test), deny(clippy::expect_used))]
+#![cfg_attr(not(test), deny(clippy::todo))]
+#![cfg_attr(not(test), deny(clippy::unimplemented))]
 
 mod error;
 

ddcommon-ffi/src/option.rs

@@ -30,6 +30,7 @@ impl<T> Option<T> {
 
     pub fn unwrap_none(self) {
         match self {
+            #[allow(clippy::panic)]
             Option::Some(_) => panic!("Called ffi::Option::unwrap_none but option was Some(_)"),
             Option::None => {}
         }

ddcommon-ffi/src/result.rs

@@ -36,6 +36,7 @@ impl<T> Result<T> {
     pub fn unwrap(self) -> T {
         match self {
             Self::Ok(v) => v,
+            #[allow(clippy::panic)]
             Self::Err(err) => panic!("{err}"),
         }
     }

ddcommon-ffi/src/string.rs

@@ -30,6 +30,7 @@ impl From<String> for StringWrapper {
 impl From<StringWrapper> for String {
     fn from(mut value: StringWrapper) -> Self {
         let msg = std::mem::take(&mut value.message);
+        #[allow(clippy::unwrap_used)]
         String::from_utf8(msg.into()).unwrap()
     }
 }
@@ -86,6 +87,7 @@ impl StringWrapperResult {
     pub fn unwrap(self) -> StringWrapper {
         match self {
             StringWrapperResult::Ok(s) => s,
+            #[allow(clippy::panic)]
             StringWrapperResult::Err(e) => panic!("{e}"),
         }
     }

ddcommon/Cargo.toml

@@ -29,7 +29,6 @@ hyper = { version = "0.14", features = [
 ], default-features = false }
 cc = "1.1.31"
 hyper-util = "0.1.3"
-lazy_static = "1.4"
 log = { version = "0.4" }
 pin-project = "1"
 rand = "0.8.3"