ekump/APMSP-1827 add warnings for panics (#915)

Add clippy warnings and allows for panic macros to most crates

Add an extension crate for mutex in ddcommon to isolate the unwrap to one location in code to avoid the allow annotations. We aren't going to stop unwrapping mutexes anytime soon. 

Replace use of lazy_static with OnceLock for ddcommon, ddtelemetry, live-debugger, tools, sidecar

Author: ekump

Cargo.toml

@@ -16,7 +16,6 @@ hashbrown = { version = "0.14.3", default-features = false, features = ["inline-
 protobuf = { version = "3.5.0", default-features = false }
 ustr = { version = "1.0.0", default-features = false }
 fnv = { version = "1.0.7", default-features = false }
-lazy_static = { version = "1.5.0", default-features = false }
 reqwest = { version = "0.12.4", features = ["json", "http2", "rustls-tls"], default-features = false }
 serde = { version = "1.0.197", default-features = false, features = ["derive"] }
 serde_json = { version = "1.0.116", default-features = false, features = ["alloc"] }

src/datadog.rs

@@ -6,22 +6,28 @@
 use crate::flusher::ShippingError;
 use datadog_protos::metrics::SketchPayload;
 use derive_more::{Display, Into};
-use lazy_static::lazy_static;
 use protobuf::Message;
 use regex::Regex;
 use reqwest;
 use reqwest::{Client, Response};
 use serde::{Serialize, Serializer};
 use serde_json;
 use std::io::Write;
+use std::sync::OnceLock;
 use std::time::Duration;
 use tracing::{debug, error};
 use zstd::stream::write::Encoder;
 
-lazy_static! {
-    static ref SITE_RE: Regex = Regex::new(r"^[a-zA-Z0-9._:-]+$").expect("invalid regex");
-    static ref URL_PREFIX_RE: Regex =
-        Regex::new(r"^https?://[a-zA-Z0-9._:-]+$").expect("invalid regex");
+// TODO: Move to the more ergonomic LazyLock when MSRV is 1.80
+static SITE_RE: OnceLock<Regex> = OnceLock::new();
+fn get_site_re() -> &'static Regex {
+    #[allow(clippy::expect_used)]
+    SITE_RE.get_or_init(|| Regex::new(r"^[a-zA-Z0-9._:-]+$").expect("invalid regex"))
+}
+static URL_PREFIX_RE: OnceLock<Regex> = OnceLock::new();
+fn get_url_prefix_re() -> &'static Regex {
+    #[allow(clippy::expect_used)]
+    URL_PREFIX_RE.get_or_init(|| Regex::new(r"^https?://[a-zA-Z0-9._:-]+$").expect("invalid regex"))
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Display, Into)]
@@ -36,7 +42,7 @@ impl Site {
         // Datadog sites are generally domain names. In particular, they shouldn't have any slashes
         // in them. We expect this to be coming from a `DD_SITE` environment variable or the `site`
         // config field.
-        if SITE_RE.is_match(&site) {
+        if get_site_re().is_match(&site) {
             Ok(Site(site))
         } else {
             Err(SiteError(site))
@@ -49,7 +55,7 @@ impl Site {
 pub struct UrlPrefixError(String);
 
 fn validate_url_prefix(prefix: &str) -> Result<(), UrlPrefixError> {
-    if URL_PREFIX_RE.is_match(prefix) {
+    if get_url_prefix_re().is_match(prefix) {
         Ok(())
     } else {
         Err(UrlPrefixError(prefix.to_owned()))
@@ -111,6 +117,7 @@ impl MetricsIntakeUrlPrefix {
 
     #[inline]
     fn new_expect_validated(validated_prefix: String) -> Self {
+        #[allow(clippy::expect_used)]
         validate_url_prefix(&validated_prefix).expect("Invalid URL prefix");
 
         Self(validated_prefix)

src/dogstatsd.rs

@@ -35,6 +35,8 @@ impl BufferReader {
                 // Max buffer size is configurable in Go Agent and the default is 8KB
                 // https://github.com/DataDog/datadog-agent/blob/85939a62b5580b2a15549f6936f257e61c5aa153/pkg/config/config_template.yaml#L2154-L2158
                 let mut buf = [0; 8192];
+
+                #[allow(clippy::expect_used)]
                 let (amt, src) = socket
                     .recv_from(&mut buf)
                     .await
@@ -54,7 +56,9 @@ impl DogStatsD {
         cancel_token: tokio_util::sync::CancellationToken,
     ) -> DogStatsD {
         let addr = format!("{}:{}", config.host, config.port);
+
         // TODO (UDS socket)
+        #[allow(clippy::expect_used)]
         let socket = tokio::net::UdpSocket::bind(addr)
             .await
             .expect("couldn't bind to address");
@@ -74,11 +78,14 @@ impl DogStatsD {
     }
 
     async fn consume_statsd(&self) {
+        #[allow(clippy::expect_used)]
         let (buf, src) = self
             .buffer_reader
             .read()
             .await
             .expect("didn't receive data");
+
+        #[allow(clippy::expect_used)]
         let msgs = std::str::from_utf8(&buf).expect("couldn't parse as string");
         debug!("Received message: {} from {}", msgs, src);
         let statsd_metric_strings = msgs.split('\n');
@@ -112,6 +119,7 @@ impl DogStatsD {
             })
             .collect();
         if !all_valid_metrics.is_empty() {
+            #[allow(clippy::expect_used)]
             let mut guarded_aggregator = self.aggregator.lock().expect("lock poisoned");
             for a_valid_value in all_valid_metrics {
                 let _ = guarded_aggregator.insert(a_valid_value);

src/flusher.rs

@@ -39,6 +39,7 @@ impl Flusher {
 
     pub async fn flush(&mut self) {
         let (all_series, all_distributions) = {
+            #[allow(clippy::expect_used)]
             let mut aggregator = self.aggregator.lock().expect("lock poisoned");
             (
                 aggregator.consume_metrics(),

src/lib.rs

@@ -1,6 +1,12 @@
 // Copyright 2023-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))]
+
 pub mod aggregator;
 pub mod constants;
 pub mod datadog;

src/metric.rs

@@ -5,19 +5,24 @@ use crate::errors::ParseError;
 use crate::{constants, datadog};
 use ddsketch_agent::DDSketch;
 use fnv::FnvHasher;
-use lazy_static::lazy_static;
 use protobuf::Chars;
 use regex::Regex;
 use std::hash::{Hash, Hasher};
+use std::sync::OnceLock;
 use ustr::Ustr;
 
 pub const EMPTY_TAGS: SortedTags = SortedTags { values: Vec::new() };
 
 // https://docs.datadoghq.com/developers/dogstatsd/datagram_shell?tab=metrics#dogstatsd-protocol-v13
-lazy_static! {
-    static ref METRIC_REGEX: Regex = Regex::new(
-        r"^(?P<name>[^:]+):(?P<values>[^|]+)\|(?P<type>[a-zA-Z]+)(?:\|@(?P<sample_rate>[\d.]+))?(?:\|#(?P<tags>[^|]+))?(?:\|c:(?P<container_id>[^|]+))?(?:\|T(?P<timestamp>[^|]+))?$",
-    ).expect("Failed to create metric regex");
+static METRIC_REGEX: OnceLock<Regex> = OnceLock::new();
+fn get_metric_regex() -> &'static Regex {
+    #[allow(clippy::expect_used)]
+    METRIC_REGEX.get_or_init(|| {
+        Regex::new(
+            r"^(?P<name>[^:]+):(?P<values>[^|]+)\|(?P<type>[a-zA-Z]+)(?:\|@(?P<sample_rate>[\d.]+))?(?:\|#(?P<tags>[^|]+))?(?:\|c:(?P<container_id>[^|]+))?(?:\|T(?P<timestamp>[^|]+))?$",
+        )
+        .expect("Failed to create metric regex")
+    })
 }
 
 #[derive(Clone, Debug)]
@@ -181,6 +186,7 @@ impl Metric {
         tags: Option<SortedTags>,
         timestamp: Option<i64>,
     ) -> Metric {
+        #[allow(clippy::expect_used)]
         let parsed_timestamp = timestamp_to_bucket(timestamp.unwrap_or_else(|| {
             std::time::UNIX_EPOCH
                 .elapsed()
@@ -204,6 +210,7 @@ impl Metric {
 // Round down to the nearest 10 seconds
 // to form a bucket of metric contexts aggregated per 10s
 pub fn timestamp_to_bucket(timestamp: i64) -> i64 {
+    #[allow(clippy::expect_used)]
     let now_seconds: i64 = std::time::UNIX_EPOCH
         .elapsed()
         .expect("unable to poll clock, unrecoverable")
@@ -228,7 +235,7 @@ pub fn timestamp_to_bucket(timestamp: i64) -> i64 {
 /// example aj-test.increment:1|c|#user:aj-test from 127.0.0.1:50983
 pub fn parse(input: &str) -> Result<Metric, ParseError> {
     // TODO must enforce / exploit constraints given in `constants`.
-    if let Some(caps) = METRIC_REGEX.captures(input) {
+    if let Some(caps) = get_metric_regex().captures(input) {
         // unused for now
         // let sample_rate = caps.name("sample_rate").map(|m| m.as_str());
 
@@ -238,8 +245,14 @@ pub fn parse(input: &str) -> Result<Metric, ParseError> {
         } else {
             tags = None;
         }
+
+        #[allow(clippy::unwrap_used)]
         let val = first_value(caps.name("values").unwrap().as_str())?;
+
+        #[allow(clippy::unwrap_used)]
         let t = caps.name("type").unwrap().as_str();
+
+        #[allow(clippy::expect_used)]
         let now = std::time::UNIX_EPOCH
             .elapsed()
             .expect("unable to poll clock, unrecoverable")
@@ -266,6 +279,7 @@ pub fn parse(input: &str) -> Result<Metric, ParseError> {
                 return Err(ParseError::Raw(format!("Invalid metric type: {t}")));
             }
         };
+        #[allow(clippy::unwrap_used)]
         let name = Ustr::from(caps.name("name").unwrap().as_str());
         let id = id(name, &tags, parsed_timestamp);
         return Ok(Metric {