Add basic metrics to sys-lend

Author: mvines

src/bin/sys-lend.rs

@@ -19,7 +19,7 @@ use {
     },
     std::collections::{HashMap, HashSet},
     sys::{
-        app_version,
+        app_version, metrics,
         notifier::*,
         priority_fee::{apply_priority_fee, PriorityFee},
         send_transaction_until_expired,
@@ -43,6 +43,32 @@ enum Operation {
     Withdraw,
 }
 
+mod dp {
+    use super::*;
+
+    pub fn supply_balance(
+        pool: &str,
+        address: &Pubkey,
+        maybe_token: MaybeToken,
+        ui_amount: f64,
+    ) -> metrics::Point {
+        metrics::Point::new("sys_lend::supply_balance")
+            .tag("pool", pool)
+            .tag("address", metrics::dp::pubkey_to_value(address))
+            .tag("token", maybe_token.name())
+            .field("amount", ui_amount)
+            .timestamp(metrics::dp::now())
+    }
+
+    pub fn supply_apy(pool: &str, maybe_token: MaybeToken, apy_bps: u64) -> metrics::Point {
+        metrics::Point::new("sys_lend::supply_apy")
+            .tag("pool", pool)
+            .tag("token", maybe_token.name())
+            .field("apy_bps", apy_bps as f64)
+            .timestamp(metrics::dp::now())
+    }
+}
+
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     solana_logger::setup_with_default("solana=info");
@@ -292,9 +318,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             let bps = matches.is_present("bps");
 
             let apy = apr_to_apy(pool_supply_apr(&rpc_client, &pool, token)?) * 100.;
+            let apy_as_bps = (apy * 100.) as u64;
 
             let value = if bps {
-                format!("{:.0}", apy * 100.)
+                format!("{}", apy_as_bps)
             } else {
                 format!("{:.2}", apy)
             };
@@ -307,23 +334,31 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             if !raw {
                 notifier.send(&msg).await;
             }
+            metrics::push(dp::supply_apy(&pool, token, apy_as_bps)).await;
             println!("{msg}");
         }
         ("supply-balance", Some(matches)) => {
             let pool = value_t_or_exit!(matches, "pool", String);
             let address = pubkey_of(matches, "address").unwrap();
             let token = MaybeToken::from(value_t!(matches, "token", Token).ok());
 
-            let supply_balance = pool_supply_balance(&rpc_client, &pool, token, address)?;
+            let amount = pool_supply_balance(&rpc_client, &pool, token, address)?;
             let apr = pool_supply_apr(&rpc_client, &pool, token)?;
 
             let msg = format!(
                 "{}: {} supplied at {:.2}%",
                 pool,
-                token.format_amount(supply_balance),
+                token.format_amount(amount),
                 apr_to_apy(apr) * 100.
             );
             notifier.send(&msg).await;
+            metrics::push(dp::supply_balance(
+                &pool,
+                &address,
+                token,
+                token.ui_amount(amount),
+            ))
+            .await;
             println!("{msg}");
         }
         ("deposit" | "withdraw", Some(matches)) => {
@@ -504,6 +539,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         _ => unreachable!(),
     }
 
+    metrics::send(metrics::env_config()).await;
     Ok(())
 }
 

src/main.rs

@@ -4342,13 +4342,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                                 .required(true)
                                 .help("Access Token"),
                         )
-                        .arg(
-                            Arg::with_name("org_id")
-                                .value_name("ORGANIZATION ID")
-                                .takes_value(true)
-                                .required(true)
-                                .help("Organization Id"),
-                        )
                         .arg(
                             Arg::with_name("bucket")
                                 .value_name("BUCKET")
@@ -5940,20 +5933,17 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 Some(MetricsConfig {
                     url,
                     token: _,
-                    org_id,
                     bucket,
                 }) => {
                     println!("Url: {url}");
                     println!("Token: ********");
-                    println!("Organization Id: {org_id}");
                     println!("Bucket: {bucket}");
                 }
             },
             ("set", Some(arg_matches)) => {
                 db.set_metrics_config(MetricsConfig {
                     url: value_t_or_exit!(arg_matches, "url", String),
                     token: value_t_or_exit!(arg_matches, "token", String),
-                    org_id: value_t_or_exit!(arg_matches, "org_id", String),
                     bucket: value_t_or_exit!(arg_matches, "bucket", String),
                 })?;
                 println!("InfluxDb configuration set");

src/metrics.rs

@@ -1,8 +1,8 @@
-pub use influxdb_client::Client;
+pub use influxdb_client::{Client, Point};
 use {
-    influxdb_client::{Point, Precision},
+    influxdb_client::Precision,
     serde::{Deserialize, Serialize},
-    std::sync::Arc,
+    std::{env, sync::Arc},
     tokio::sync::RwLock,
 };
 
@@ -14,25 +14,33 @@ lazy_static::lazy_static! {
 pub struct MetricsConfig {
     pub url: String,
     pub token: String,
-    pub org_id: String,
     pub bucket: String,
 }
 
+pub fn env_config() -> Option<MetricsConfig> {
+    Some(MetricsConfig {
+        url: env::var("INFLUX_URL").ok()?,
+        token: env::var("INFLUX_API_TOKEN").ok()?,
+        bucket: env::var("INFLUX_BUCKET")
+            .ok()
+            .unwrap_or_else(|| "sys".into()),
+    })
+}
+
 pub async fn push(point: Point) {
     POINTS.write().await.push(point);
 }
 
 pub async fn send(config: Option<MetricsConfig>) {
     if let Some(config) = config {
         let client = Client::new(config.url, config.token)
-            .with_org_id(config.org_id)
             .with_bucket(config.bucket)
             .with_precision(Precision::MS);
-        // let client = client.insert_to_stdout();
+        //let client = client.insert_to_stdout();
         client
             .insert_points(
                 &*POINTS.write().await,
-                influxdb_client::TimestampOptions::FromPoint,
+                influxdb_client::TimestampOptions::None,
             )
             .await
             .unwrap_or_else(|err| eprintln!("Failed to send metrics: {err:?}"));
@@ -50,11 +58,11 @@ pub mod dp {
         solana_sdk::pubkey::Pubkey,
     };
 
-    fn pubkey_to_value(p: &Pubkey) -> Value {
+    pub fn pubkey_to_value(p: &Pubkey) -> Value {
         Value::Str(p.to_string())
     }
 
-    fn now() -> Timestamp {
+    pub fn now() -> Timestamp {
         Timestamp::Int(Utc::now().timestamp_millis())
     }