quicknode-cli 0.1.7

Command-line interface for the Quicknode SDK
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

//! `qn metrics …` — account and endpoint metric series.

use clap::{Args as ClapArgs, Subcommand};
use quicknode_sdk::admin::{GetAccountMetricsRequest, GetEndpointMetricsRequest};
use serde::Serialize;

use crate::context::Ctx;
use crate::errors::CliError;
use crate::output::Render;
use crate::retry::retrying;

#[derive(Debug, ClapArgs)]
pub struct Args {
    #[command(subcommand)]
    pub cmd: MetricsCmd,
}

#[derive(Debug, Subcommand)]
pub enum MetricsCmd {
    /// Account-level metric series (credits/calls/latency).
    Account(AccountArgs),
    /// Endpoint-level metric series.
    Endpoint(EndpointArgs),
}

#[derive(Debug, ClapArgs)]
pub struct AccountArgs {
    /// Period.
    #[arg(long, value_parser = ["hour", "day", "week", "month"])]
    pub period: String,
    /// Metric name.
    #[arg(long)]
    pub metric: String,
    /// Percentile (for latency metrics).
    #[arg(long)]
    pub percentile: Option<String>,
}

#[derive(Debug, ClapArgs)]
pub struct EndpointArgs {
    /// Endpoint id.
    pub id: String,
    /// Period.
    #[arg(long, value_parser = ["hour", "day", "week", "month"])]
    pub period: String,
    /// Metric name.
    #[arg(long)]
    pub metric: String,
}

pub async fn run(args: Args, ctx: Ctx) -> Result<(), CliError> {
    match args.cmd {
        MetricsCmd::Account(a) => account(a, ctx).await,
        MetricsCmd::Endpoint(a) => endpoint(a, ctx).await,
    }
}

async fn account(a: AccountArgs, ctx: Ctx) -> Result<(), CliError> {
    let req = GetAccountMetricsRequest {
        period: a.period,
        metric: a.metric,
        percentile: a.percentile,
    };
    let resp = retrying(ctx.global.retries, || {
        ctx.sdk.admin.get_account_metrics(&req)
    })
    .await?;
    crate::output::emit(&ctx.out, &AccountMetricsView(resp))
}

async fn endpoint(a: EndpointArgs, ctx: Ctx) -> Result<(), CliError> {
    let req = GetEndpointMetricsRequest {
        period: a.period,
        metric: a.metric,
    };
    let resp = retrying(ctx.global.retries, || {
        ctx.sdk.admin.get_endpoint_metrics(&a.id, &req)
    })
    .await?;
    crate::output::emit(&ctx.out, &EndpointMetricsView(resp))
}

#[derive(Serialize)]
struct AccountMetricsView(quicknode_sdk::admin::GetAccountMetricsResponse);

impl Render for AccountMetricsView {
    fn render_table(
        &self,
        w: &mut dyn std::io::Write,
        ctx: &crate::output::OutputCtx,
    ) -> std::io::Result<()> {
        for m in &self.0.data {
            super::endpoint::render::metric_series(w, m, ctx)?;
        }
        Ok(())
    }
}

#[derive(Serialize)]
struct EndpointMetricsView(quicknode_sdk::admin::GetEndpointMetricsResponse);

impl Render for EndpointMetricsView {
    fn render_table(
        &self,
        w: &mut dyn std::io::Write,
        ctx: &crate::output::OutputCtx,
    ) -> std::io::Result<()> {
        for m in &self.0.data {
            super::endpoint::render::metric_series(w, m, ctx)?;
        }
        Ok(())
    }
}