fix(deps): bump metrics from 0.21.1 to 0.22.0

tonlibjson-client/Cargo.toml

@@ -32,7 +32,7 @@ derive-new = "0.6.0"
 tokio-retry = "0.3"
 bytes = "1.5"
 crc = "3.0.1"
-metrics = "0.21.1"
+metrics = "0.22.0"
 
 [dev-dependencies]
 tracing-test = { workspace = true }

tonlibjson-client/src/cursor_client.rs

@@ -20,7 +20,6 @@ use tower::load::peak_ewma::Cost;
 use tower::load::PeakEwma;
 use tower::load::Load;
 use tracing::{instrument, trace};
-use metrics::{absolute_counter, describe_counter, describe_gauge, gauge};
 use quick_cache::sync::Cache;
 use crate::router::BlockCriteria;
 use crate::block::{BlocksGetMasterchainInfo, BlocksGetShards, BlocksHeader, BlocksMasterchainInfo, BlocksShards, Sync, TonBlockId, TonBlockIdExt};
@@ -280,11 +279,11 @@ impl CursorClient {
     }
 
     pub(crate) fn new(id: String, client: ConcurrencyLimit<SharedService<PeakEwma<Client>>>) -> Self {
-        describe_counter!("ton_liteserver_last_seqno", "The seqno of the latest block that is available for the liteserver to sync");
-        describe_counter!("ton_liteserver_synced_seqno", "The seqno of the last block with which the liteserver is actually synchronized");
-        describe_counter!("ton_liteserver_first_seqno", "The seqno of the first block that is available for the liteserver to request");
-        describe_gauge!("ton_liteserver_requests_total", "Total count of requests");
-        describe_gauge!("ton_liteserver_requests", "Number of concurrent requests");
+        metrics::describe_counter!("ton_liteserver_last_seqno", "The seqno of the latest block that is available for the liteserver to sync");
+        metrics::describe_counter!("ton_liteserver_synced_seqno", "The seqno of the last block with which the liteserver is actually synchronized");
+        metrics::describe_counter!("ton_liteserver_first_seqno", "The seqno of the first block that is available for the liteserver to request");
+        metrics::describe_gauge!("ton_liteserver_requests_total", "Total count of requests");
+        metrics::describe_gauge!("ton_liteserver_requests", "Number of concurrent requests");
 
         let id = Cow::from(id);
         let client = ConcurrencyMetric::new(client, id.clone());
@@ -603,7 +602,7 @@ impl FirstBlockDiscover {
         let cur = self.current.as_ref().map(|n| n.id.seqno + 32);
         let (mfb, wfb) = find_first_blocks(&mut self.client, &start, lhs, cur).await?;
 
-        absolute_counter!("ton_liteserver_first_seqno", mfb.id.seqno as u64, "liteserver_id" => self.id.clone());
+        metrics::counter!("ton_liteserver_first_seqno", "liteserver_id" => self.id.clone()).absolute(mfb.id.seqno as u64);
 
         self.registry.upsert_left(&mfb);
         for header in &wfb {
@@ -631,7 +630,7 @@ impl LastBlockDiscover {
         loop {
             timer.tick().await;
 
-            gauge!("ton_liteserver_requests", self.client.load() as f64, "liteserver_id" => self.id.clone());
+            metrics::gauge!("ton_liteserver_requests", "liteserver_id" => self.id.clone()).set(self.client.load() as f64);
 
             match self.next().await {
                 Ok(Some(masterchain_info)) => { current.replace(masterchain_info); },
@@ -648,10 +647,10 @@ impl LastBlockDiscover {
             }
         }
 
-        absolute_counter!("ton_liteserver_last_seqno", masterchain_info.last.seqno as u64, "liteserver_id" => self.id.clone());
+        metrics::counter!("ton_liteserver_last_seqno", "liteserver_id" => self.id.clone()).absolute(masterchain_info.last.seqno as u64);
 
         let (master_header, last_work_chain_header) = fetch_last_headers(&mut self.client).await?;
-        absolute_counter!("ton_liteserver_synced_seqno", master_header.id.seqno as u64, "liteserver_id" => self.id.clone());
+        metrics::counter!("ton_liteserver_synced_seqno", "liteserver_id" => self.id.clone()).absolute(master_header.id.seqno as u64);
 
         self.registry.upsert_right(&master_header);
         for header in &last_work_chain_header {

tonlibjson-client/src/metric.rs

@@ -3,7 +3,6 @@ use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{Context, Poll};
-use metrics::counter;
 use tower::Service;
 use pin_project::{pin_project, pinned_drop};
 use tower::load::Load;
@@ -75,7 +74,7 @@ impl<S, Request> Service<Request> for ConcurrencyMetric<S>
     fn call(&mut self, req: Request) -> Self::Future {
         let req_type = std::any::type_name::<Request>();
 
-        counter!("ton_liteserver_requests_total", 1, "liteserver_id" => self.liteserver_id.clone(), r"request_type" => req_type);
+        metrics::counter!("ton_liteserver_requests_total", "liteserver_id" => self.liteserver_id.clone(), r"request_type" => req_type).increment(1);
 
         let future = self.inner.call(req);
 

tonlibjson-client/src/retry.rs

@@ -59,7 +59,7 @@ impl<T: Clone, Res, E> Policy<T, Res, E> for RetryPolicy {
 
                 match self.budget.withdraw() {
                     Ok(_) => {
-                        metrics::increment_counter!("ton_retry_budget_withdraw_success", "request_type" => request_type);
+                        metrics::counter!("ton_retry_budget_withdraw_success", "request_type" => request_type).increment(1);
 
                         Some({
                             let mut pol = self.clone();
@@ -77,7 +77,7 @@ impl<T: Clone, Res, E> Policy<T, Res, E> for RetryPolicy {
                             }.boxed()
                     }) },
                     Err(_) => {
-                        metrics::increment_counter!("ton_retry_budget_withdraw_fail", "request_type" => request_type);
+                        metrics::counter!("ton_retry_budget_withdraw_fail", "request_type" => request_type).increment(1);
 
                         None
                     }

tonlibjson-client/src/router.rs

@@ -99,12 +99,12 @@ impl Service<&Route> for Router {
             return std::future::ready(Ok(services)).boxed();
         }
 
-        metrics::increment_counter!("ton_router_miss_count");
+        metrics::counter!("ton_router_miss_count").increment(1);
 
         if let Route::Block { chain, criteria } = req {
             let distance = self.distance_to(chain, criteria);
             if distance.is_some_and(|d| d <= 1) {
-                metrics::increment_counter!("ton_router_delayed_count");
+                metrics::counter!("ton_router_delayed_count").increment(1);
 
                 let req = *req;
                 let svcs = self.services.clone();
@@ -116,7 +116,7 @@ impl Service<&Route> for Router {
 
                         let services = req.choose(&svcs);
                         if !services.is_empty() {
-                            metrics::increment_counter!("ton_router_delayed_hit_count");
+                            metrics::counter!("ton_router_delayed_hit_count").increment(1);
 
                             return Ok(services)
                         }
@@ -125,7 +125,7 @@ impl Service<&Route> for Router {
             } else {
                 let services = Route::Latest.choose(&self.services);
                 if !services.is_empty() {
-                    metrics::increment_counter!("ton_router_fallback_hit_count");
+                    metrics::counter!("ton_router_fallback_hit_count").increment(1);
                     return std::future::ready(Ok(services)).boxed();
                 }
             }