Merge pull request #2546 from input-output-hk/ctl/2494-record-uage-of-client-type-in-metrics

Record usage of client type in metrics

Author: Clément TURMEL

CHANGELOG.md

@@ -13,6 +13,8 @@ As a minor extension, we have adopted a slightly different versioning convention
 
 - Support for `Cardano node` `10.4.1` in the signer and the aggregator.
 
+- Support for recording client types in Mithril client library, CLI and WASM in the aggregator metrics.
+
 - Crates versions:
 
 | Crate | Version |

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-aggregator"
-version = "0.7.56"
+version = "0.7.57"
 description = "A Mithril Aggregator server"
 authors = { workspace = true }
 edition = { workspace = true }

examples/client-wasm-nodejs/package-lock.json

@@ -94,5 +94,17 @@ create view if not exists metrics_per_day_and_origin as select metric_date as da
 group by action, origin, date;
           "#,
         ),
+        SqlMigration::new(
+            5,
+            r#"
+create view if not exists metrics_per_day_and_client_type as select metric_date as date, action as counter_name, client_type, sum(counter) value from 
+  (
+      select action, json_extract(content, '$.content.client_type') client_type, json_extract(content, '$.content.value') counter, date(json_extract(content, '$.content.date')) metric_date 
+      from event 
+      where source='Metrics'
+  ) 
+group by action, client_type, date;
+          "#,
+        ),
     ]
 }

examples/client-wasm-web/package-lock.json

@@ -112,6 +112,26 @@ mod tests {
             Ok(result)
         }
 
+        fn get_all_metrics_by_client_type(
+            connection: Arc<ConnectionThreadSafe>,
+        ) -> StdResult<Vec<(String, String, String, i64)>> {
+            let query = "select date, counter_name, client_type, value from metrics_per_day_and_client_type";
+            let mut statement = connection.prepare(query)?;
+            let mut result = Vec::new();
+            while let Ok(sqlite::State::Row) = statement.next() {
+                result.push((
+                    statement.read::<String, _>("date")?,
+                    statement.read::<String, _>("counter_name")?,
+                    statement
+                        .read::<Option<String>, _>("client_type")?
+                        .unwrap_or_default(),
+                    statement.read::<i64, _>("value")?,
+                ));
+            }
+
+            Ok(result)
+        }
+
         /// Insert a metric event in the database.
         /// date format is "%Y-%m-%d %H:%M:%S %z", example: "2015-09-05 23:56:04 +0000"
         fn insert_metric_event_with_origin(
@@ -129,6 +149,30 @@ mod tests {
                 value,
                 Duration::from_secs(5),
                 origin.to_string(),
+                "CLIENT_TYPE_A".to_string(),
+                metric_date.into(),
+            );
+
+            let _event = persister.persist(message).unwrap();
+        }
+
+        fn insert_metric_event_message(
+            persister: &EventPersister,
+            date: &str,
+            metric_name: &str,
+            origin: &str,
+            client_type: &str,
+            value: i64,
+        ) {
+            let metric_date =
+                DateTime::parse_from_str(&format!("{date} +0000"), "%Y-%m-%d %H:%M:%S %z").unwrap();
+
+            let message = UsageReporter::create_metrics_event_message(
+                metric_name.to_string(),
+                value,
+                Duration::from_secs(5),
+                origin.to_string(),
+                client_type.to_string(),
                 metric_date.into(),
             );
 
@@ -300,6 +344,30 @@ mod tests {
             assert!(result.contains(&("2024-10-30", "metric_1", "ORIGIN_B", 7)));
         }
 
+        #[test]
+        fn vue_metrics_per_day_and_client_type() {
+            fn tuple_with_str(t: &(String, String, String, i64)) -> (&str, &str, &str, i64) {
+                (t.0.as_str(), t.1.as_str(), t.2.as_str(), t.3)
+            }
+
+            let connection = Arc::new(event_store_db_connection().unwrap());
+            let persister = EventPersister::new(connection.clone());
+
+            insert_metric_event_message(
+                &persister,
+                "2024-10-29 21:00:00",
+                "metric_1",
+                "ORIGIN_A",
+                "CLIENT_TYPE_A",
+                15,
+            );
+
+            let result = get_all_metrics_by_client_type(connection).unwrap();
+            let result: Vec<_> = result.iter().map(tuple_with_str).collect();
+
+            assert!(result.contains(&("2024-10-29", "metric_1", "CLIENT_TYPE_A", 15)));
+        }
+
         #[test]
         fn sum_metric_per_day_and_origin_on_old_event() {
             fn tuple_with_str(t: &(String, String, String, i64)) -> (&str, &str, &str, i64) {

mithril-aggregator/Cargo.toml

@@ -28,7 +28,7 @@ fn artifact_cardano_database_by_id(
 ) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
     warp::path!("artifact" / "cardano-database" / String)
         .and(warp::get())
-        .and(middlewares::with_origin_tag(dependency_manager))
+        .and(middlewares::with_client_metadata(dependency_manager))
         .and(middlewares::with_logger(dependency_manager))
         .and(middlewares::with_http_message_service(dependency_manager))
         .and(middlewares::with_metrics_service(dependency_manager))
@@ -64,14 +64,16 @@ fn serve_cardano_database_dir(
 }
 
 mod handlers {
-    use crate::http_server::routes::reply;
-    use crate::services::MessageService;
-    use crate::MetricsService;
     use slog::{debug, warn, Logger};
     use std::convert::Infallible;
     use std::sync::Arc;
     use warp::http::StatusCode;
 
+    use crate::http_server::routes::middlewares::ClientMetadata;
+    use crate::http_server::routes::reply;
+    use crate::services::MessageService;
+    use crate::MetricsService;
+
     pub const LIST_MAX_ITEMS: usize = 20;
 
     /// List artifacts
@@ -94,14 +96,17 @@ mod handlers {
     /// Get artifact by signed entity id
     pub async fn get_artifact_by_signed_entity_id(
         signed_entity_id: String,
-        origin_tag: Option<String>,
+        client_metadata: ClientMetadata,
         logger: Logger,
         http_message_service: Arc<dyn MessageService>,
         metrics_service: Arc<MetricsService>,
     ) -> Result<impl warp::Reply, Infallible> {
         metrics_service
             .get_artifact_detail_cardano_database_total_served_since_startup()
-            .increment(&[origin_tag.as_deref().unwrap_or_default()]);
+            .increment(&[
+                client_metadata.origin_tag.as_deref().unwrap_or_default(),
+                client_metadata.client_type.as_deref().unwrap_or_default(),
+            ]);
 
         match http_message_service
             .get_cardano_database_message(&signed_entity_id)
@@ -178,7 +183,7 @@ mod tests {
         CardanoDatabaseSnapshotMessage,
     };
     use mithril_common::test_utils::apispec::APISpec;
-    use mithril_common::MITHRIL_ORIGIN_TAG_HEADER;
+    use mithril_common::{MITHRIL_CLIENT_TYPE_HEADER, MITHRIL_ORIGIN_TAG_HEADER};
     use mithril_persistence::sqlite::HydrationError;
     use serde_json::Value::Null;
     use std::sync::Arc;
@@ -275,12 +280,13 @@ mod tests {
         let initial_counter_value = dependency_manager
             .metrics_service
             .get_artifact_detail_cardano_database_total_served_since_startup()
-            .get(&["TEST"]);
+            .get(&["TEST", "CLI"]);
 
         request()
             .method(method)
             .path(path)
             .header(MITHRIL_ORIGIN_TAG_HEADER, "TEST")
+            .header(MITHRIL_CLIENT_TYPE_HEADER, "CLI")
             .reply(&setup_router(RouterState::new_with_origin_tag_white_list(
                 dependency_manager.clone(),
                 &["TEST"],
@@ -292,7 +298,7 @@ mod tests {
             dependency_manager
                 .metrics_service
                 .get_artifact_detail_cardano_database_total_served_since_startup()
-                .get(&["TEST"])
+                .get(&["TEST", "CLI"]),
         );
     }