prepare for release

.mise.toml

@@ -0,0 +1,2 @@
+[tools]
+rust = "1.74"

CHANGELOG.md

@@ -9,6 +9,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [0.9.0] - 2024-11-25
+
+### Added
+
+- New `event_with_options!` macro, [see the original repo](https://github.com/mcasper/dogstatsd-rs) for more details
+
+### Changed
+
+- Bump `dogstatsd` to 0.12
+- Bumped MSRV to 1.74
+
+---
+
 ## [0.8.0] - 2024-06-21
 
 ## Changed
@@ -151,7 +164,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 
 
-[Unreleased]: https://github.com/primait/prima_datadog.rs/compare/0.8.0...HEAD
+
+[Unreleased]: https://github.com/primait/prima_datadog.rs/compare/0.9.0...HEAD
+[0.9.0]: https://github.com/primait/prima_datadog.rs/compare/0.8.0...0.9.0
 [0.8.0]: https://github.com/primait/prima_datadog.rs/compare/0.7.2...0.8.0
 [0.7.2]: https://github.com/primait/prima_datadog.rs/compare/0.7.1...0.7.2
 [0.7.1]: https://github.com/primait/prima_datadog.rs/compare/0.7.0...0.7.1

Cargo.toml

@@ -3,7 +3,7 @@ description = "An opinionated library to share code and approach to Datadog logg
 edition = "2018"
 license = "MIT"
 name = "prima_datadog"
-version = "0.8.0"
+version = "0.9.0"
 
 [features]
 default = []

Dockerfile

@@ -1,4 +1,4 @@
-FROM rust:1.72.0
+FROM rust:1.74.0
 
 WORKDIR /code
 

src/client.rs

@@ -1,6 +1,7 @@
 use std::future::Future;
 
 use async_trait::async_trait;
+use dogstatsd::EventOptions;
 
 use crate::{ServiceCheckOptions, ServiceStatus, TagsProvider};
 
@@ -75,6 +76,11 @@ pub trait DogstatsdClient {
     fn event<S>(&self, title: &str, text: &str, tags: impl TagsProvider<S>)
     where
         S: AsRef<str>;
+
+    /// Send a custom event as a title and a body
+    fn event_with_options<S>(&self, title: &str, text: &str, tags: impl TagsProvider<S>, options: Option<EventOptions>)
+    where
+        S: AsRef<str>;
 }
 
 #[async_trait]
@@ -172,4 +178,11 @@ impl DogstatsdClient for dogstatsd::Client {
     {
         let _ = self.event(title, text, tags.as_ref());
     }
+
+    fn event_with_options<S>(&self, title: &str, text: &str, tags: impl TagsProvider<S>, options: Option<EventOptions>)
+    where
+        S: AsRef<str>,
+    {
+        let _ = self.event_with_options(title, text, tags.as_ref(), options);
+    }
 }

src/lib.rs

@@ -57,6 +57,8 @@
 //! service_check!("test", ServiceStatus::OK, ServiceCheckOptions::default());
 //! # event!("test", "test event");
 //! event!("test", "test event"; "some" => "data");
+//! # event_with_options!("test", "test event", EventOptions::new());
+//! event_with_options!("test", "test event", EventOptions::new(); "some" => "data");
 //! ```
 //!
 //! This is an example of a custom metric, in this case based on an enum type, but it can really be
@@ -114,6 +116,7 @@
 use std::future::Future;
 
 use configuration::Configuration;
+use dogstatsd::EventOptions;
 pub use dogstatsd::{ServiceCheckOptions, ServiceStatus};
 use once_cell::sync::OnceCell;
 
@@ -295,6 +298,18 @@ impl Datadog<dogstatsd::Client> {
         }
     }
 
+    /// Send a custom event as a title, a body and some options
+    pub fn event_with_options<S: AsRef<str>>(
+        metric: impl AsRef<str>,
+        text: impl AsRef<str>,
+        tags: impl TagsProvider<S>,
+        options: Option<EventOptions>,
+    ) {
+        if let Some(instance) = INSTANCE.get() {
+            instance.do_event_with_options(metric.as_ref(), text.as_ref(), tags, options);
+        }
+    }
+
     /// Acquire a timing guard.
     /// When this guard is dropped, it will emit a timing metric for the duration it
     /// existed. The metric name is metric, and the tags are tags.
@@ -455,4 +470,19 @@ impl<C: DogstatsdClient> Datadog<C> {
             self.tag_tracker.track(&self.inner, metric.as_ref(), tags),
         );
     }
+
+    pub(crate) fn do_event_with_options<S: AsRef<str>>(
+        &self,
+        metric: impl AsRef<str>,
+        text: impl AsRef<str>,
+        tags: impl TagsProvider<S>,
+        options: Option<EventOptions>,
+    ) {
+        self.inner.event_with_options(
+            metric.as_ref(),
+            text.as_ref(),
+            self.tag_tracker.track(&self.inner, metric.as_ref(), tags),
+            options,
+        );
+    }
 }

src/macros/event_with_options.rs

@@ -0,0 +1,41 @@
+/// Send a custom event as a title and a body
+/// NOTE: Try to minimise variation in tag values (avoid things like timestamps or ids). See note in lib docs!
+#[macro_export]
+macro_rules! event_with_options {
+    ($stat:path, $text:expr) => {
+        $crate::Datadog::event_with_options($stat.as_ref(), $text, $crate::EMPTY_TAGS, None);
+    };
+    ($stat:path, $text:expr, $options:expr) => {
+        $crate::Datadog::event_with_options($stat.as_ref(), $text, $crate::EMPTY_TAGS, Some($options));
+    };
+    ($stat:expr, $text:expr) => {
+        $crate::Datadog::event_with_options($stat, $text, $crate::EMPTY_TAGS, None);
+    };
+    ($stat:expr, $text:expr, $options:expr) => {
+        $crate::Datadog::event_with_options($stat, $text, $crate::EMPTY_TAGS, Some($options));
+    };
+    ($stat:path, $text:expr; $( $key:literal => $value:literal ), *) => {
+        $crate::Datadog::event_with_options($stat.as_ref(), $text, &[$(::core::concat!($key, ":", $value)), *], None);
+    };
+    ($stat:path, $text:expr, $options:expr; $( $key:literal => $value:literal ), *) => {
+        $crate::Datadog::event_with_options($stat.as_ref(), $text, &[$(::core::concat!($key, ":", $value)), *], Some($options));
+    };
+    ($stat:expr, $text:expr; $( $key:literal => $value:literal ), *) => {
+        $crate::Datadog::event_with_options($stat, $text, &[$(::core::concat!($key, ":", $value)), *], None);
+    };
+    ($stat:expr, $text:expr, $options:expr; $( $key:literal => $value:literal ), *) => {
+        $crate::Datadog::event_with_options($stat, $text, &[$(::core::concat!($key, ":", $value)), *], Some($options));
+    };
+    ($stat:path, $text:expr; $( $key:expr => $value:expr ), *) => {
+        $crate::Datadog::event_with_options($stat.as_ref(), $text, &[$(::std::format!("{}:{}", $key, $value).as_str()), *], None);
+    };
+    ($stat:path, $text:expr, $options:expr; $( $key:expr => $value:expr ), *) => {
+        $crate::Datadog::event_with_options($stat.as_ref(), $text, &[$(::std::format!("{}:{}", $key, $value).as_str()), *], Some($options));
+    };
+    ($stat:expr, $text:expr; $( $key:expr => $value:expr ), *) => {
+        $crate::Datadog::event_with_options($stat, $text, &[$(::std::format!("{}:{}", $key, $value).as_str()), *], None);
+    };
+    ($stat:expr, $text:expr, $options:expr; $( $key:expr => $value:expr ), *) => {
+        $crate::Datadog::event_with_options($stat, $text, &[$(::std::format!("{}:{}", $key, $value).as_str()), *], Some($options));
+    };
+}

src/macros/mod.rs

@@ -4,6 +4,7 @@ mod count;
 mod decr;
 mod distribution;
 mod event;
+mod event_with_options;
 mod gauge;
 mod histogram;
 mod incr;

src/tests/event_with_options.rs

@@ -0,0 +1,91 @@
+use dogstatsd::EventAlertType;
+use dogstatsd::EventOptions;
+use dogstatsd::EventPriority;
+
+use crate::event_with_options;
+use crate::tests::mocks;
+use crate::tests::TestEvent;
+use crate::Datadog;
+use crate::TagTrackerConfiguration;
+use crate::EMPTY_TAGS;
+
+#[test]
+pub fn event_with_options_with_literal() {
+    let mock = mocks::event_with_options_mock("test", "test_value", &[], None);
+    Datadog::new(mock, TagTrackerConfiguration::new()).do_event_with_options("test", "test_value", EMPTY_TAGS, None);
+}
+
+#[test]
+pub fn event_with_options_with_type() {
+    let mock = mocks::event_with_options_mock("test1_event", "test_value", &[], None);
+    Datadog::new(mock, TagTrackerConfiguration::new()).do_event_with_options(
+        TestEvent::Test1,
+        "test_value",
+        EMPTY_TAGS,
+        None,
+    );
+}
+
+#[test]
+pub fn event_with_options_with_literal_and_tags() {
+    let mock = mocks::event_with_options_mock("test", "test_value", &["added:tag", "env:test"], None);
+    Datadog::new(mock, TagTrackerConfiguration::new()).do_event_with_options(
+        "test",
+        "test_value",
+        vec!["added:tag".to_string()],
+        None,
+    );
+}
+
+#[test]
+pub fn event_with_options_with_type_and_tags() {
+    let mock = mocks::event_with_options_mock("test1_event", "test_value", &["added:tag", "env:test"], None);
+    Datadog::new(mock, TagTrackerConfiguration::new()).do_event_with_options(
+        TestEvent::Test1,
+        "test_value",
+        vec!["added:tag".to_string()],
+        None,
+    );
+}
+
+#[test]
+pub fn event_with_options_with_options() {
+    let options = Some(
+        EventOptions::new()
+            .with_alert_type(EventAlertType::Info)
+            .with_priority(EventPriority::Low)
+            .with_aggregation_key("aggregation_key")
+            .with_source_type_name("source_type_name")
+            .with_hostname("hostname")
+            .with_timestamp(12341234),
+    );
+
+    let mock = mocks::event_with_options_mock("test1_event", "test_value", &["added:tag", "env:test"], options);
+    Datadog::new(mock, TagTrackerConfiguration::new()).do_event_with_options(
+        TestEvent::Test1,
+        "test_value",
+        vec!["added:tag".to_string()],
+        options,
+    );
+}
+
+#[test]
+pub fn test_macro() {
+    let tag = String::from("tag");
+    // no tags
+    event_with_options!("test", "test_value");
+    // no tags with options
+    event_with_options!("test", "test_value", EventOptions::new());
+    // just literal tags
+    event_with_options!("test", "test_value"; "literal" => 1);
+    // just literal tags with options
+    event_with_options!("test", "test_value", EventOptions::new(); "literal" => 1);
+    // just expression tags
+    event_with_options!("test", "test_value"; "expression" => tag);
+    // just expression tags with options
+    event_with_options!("test", "test_value", EventOptions::new(); "expression" => tag);
+    // mixed tags
+    event_with_options!("test", "test_value"; "literal" => 1, "expression" => tag);
+    // mixed tags with options
+    event_with_options!("test", "test_value", EventOptions::new(); "literal" => 1, "expression" => tag);
+}

src/tests/mocks/dogstatsd_client.rs

@@ -18,6 +18,7 @@ pub(super) trait MockDogstatsdClient {
     fn set(&self, metric: &str, val: &str, tags: Vec<String>);
     fn service_check(&self, metric: &str, val: ServiceStatus, tags: Vec<String>, options: Option<ServiceCheckOptions>);
     fn event(&self, title: &str, text: &str, tags: Vec<String>);
+    fn event_with_options(&self, title: &str, text: &str, tags: Vec<String>, options: Option<EventOptions>);
 }
 
 #[async_trait]
@@ -143,4 +144,17 @@ impl<C: MockDogstatsdClient + Sync> DogstatsdClient for C {
             tags.as_ref().iter().map(|s| s.as_ref().to_string()).collect(),
         )
     }
+
+    fn event_with_options<S>(&self, title: &str, text: &str, tags: impl TagsProvider<S>, options: Option<EventOptions>)
+    where
+        S: AsRef<str>,
+    {
+        MockDogstatsdClient::event_with_options(
+            self,
+            title,
+            text,
+            tags.as_ref().iter().map(|s| s.as_ref().to_string()).collect(),
+            options,
+        )
+    }
 }

src/tests/mocks/mod.rs

@@ -48,6 +48,9 @@ mock! {
 
         /// Send a custom event as a title and a body
         fn event(&self, title: &str, text: &str, tags: Vec<String>);
+
+        /// Send a custom event as a title, a body and some options
+        fn event_with_options<'a>(&self, title: &str, text: &str, tags: Vec<String>, options: Option<EventOptions<'a>>);
     }
 }
 
@@ -236,6 +239,30 @@ pub fn event_mock(metric: &'static str, text: &'static str, tags: &'static [&str
     client_mock
 }
 
+#[allow(dead_code)]
+pub fn event_with_options_mock(
+    metric: &'static str,
+    text: &'static str,
+    tags: &'static [&str],
+    options: Option<EventOptions<'static>>,
+) -> MockClient {
+    let mut client_mock = MockClient::new();
+    client_mock
+        .expect_event_with_options()
+        .once()
+        .with(
+            eq(metric),
+            eq(text),
+            function(move |called_tags: &Vec<String>| called_tags.iter().all(|tag| tags.contains(&tag.as_str()))),
+            function(move |called_options: &Option<EventOptions<'static>>| {
+                matches!((called_options, options), (Some(_), Some(_)) | (None, None))
+            }),
+        )
+        .return_const(());
+
+    client_mock
+}
+
 pub fn expect_incr(mut mock: MockClient, metric: &'static str, tags: impl IntoIterator<Item = String>) -> MockClient {
     let tags = tags.into_iter().collect::<Vec<_>>();
     mock.expect_incr()

src/tests/mod.rs

@@ -7,6 +7,7 @@ mod count;
 mod decr;
 mod distribution;
 mod event;
+mod event_with_options;
 mod gauge;
 mod histogram;
 mod incr;