[Rust] Amazon KendraでGetSnapshots APIを使う

{
   "IndexId": "<Kendra Index ID>",
   "Interval": "期間",
   "MaxResults": ＜データ取得数＞,
   "MetricType": "メトリクスタイプ",
   "NextToken": "<任意>"
}

% aws kendra get-snapshots \
--index-id <Knedra Index ID> \
--interval "ONE_WEEK_AGO" \
--metric-type "QUERIES_BY_COUNT"

//response

{ "SnapShotTimeFilter": { "StartTime": "2024-xx-xxT00:00:00+09:00", 
"EndTime": "2024-xx-xxT23:00:00+09:00" }, 
"SnapshotsDataHeader": [ "query_content", 
"count", "ctr", "zero_click_rate", "click_depth", 
"instant_answer", "confidence" ], 
"SnapshotsData": [ 
    [ "hoge", "23", "0.0", "1.0", "0.0", "0.0", "LOW" ], 
    ・・・
], 
   "NextToken": "xxxxx" }

% cargo new kendra-edample
% cd kendra-edample
% cargo add anyhow aws-config aws-sdk-kendra tokio thiserror

use aws_sdk_kendra::{
    types::{Interval, MetricType},
    config::BehaviorVersion,
    Client,
};
use anyhow::{Context, Result};

const INDEX_ID: &str = "Kendta Index ID";
const MAX_RESULTS: i32 = 100;

#[tokio::main]
async fn main() -> Result<()> {
    let config = aws_config::load_defaults(BehaviorVersion::v2024_03_28()).await;
    let client = Client::new(&config);

    let interval = Interval::OneWeekAgo;

    // QUERIES_BY_COUNT データの取得
    let count_data = get_snapshot_data(&client, interval.clone(), MetricType::QueriesByCount)
        .await
        .context("Failed to get QUERIES_BY_COUNT data")?;
    let sorted_count_queries = sort_by_count(&count_data);

    // QUERIES_BY_ZERO_RESULT_RATE データの取得
    let zero_rate_data = get_snapshot_data(&client, interval, MetricType::QueriesByZeroResultRate)
        .await
        .context("Failed to get QUERIES_BY_ZERO_RESULT_RATE data")?;
    let sorted_zero_rate_queries = sort_by_zero_result_rate(&zero_rate_data);

    // 人気のあるクエリを出力
    println!("\n人気のあるクエリ (QUERIES_BY_COUNT):");
    for (query, count) in &sorted_count_queries {
        println!("クエリ: {}, 検索回数: {}", query, count);
    }
    println!("Total: {}", sorted_count_queries.len());

    // ゼロ結果率の高いクエリを出力
    println!("\nゼロ結果率の高いクエリ (QUERIES_BY_ZERO_RESULT_RATE):");
    for (query, zero_rate) in &sorted_zero_rate_queries {
        println!("クエリ: {}, ゼロ結果率: {}", query, zero_rate);
    }
    println!("Total: {}", sorted_zero_rate_queries.len());

    Ok(())
}

async fn get_snapshot_data(
    client: &Client,
    interval: Interval,
    metric_type: MetricType,
) -> Result<Vec<Vec<String>>> {
    let mut all_data = Vec::new();
    let mut next_token: Option<String> = None;
    let mut request_count = 0;

    loop {
        request_count += 1;
        let response = client
            .get_snapshots()
            .index_id(INDEX_ID)
            .interval(interval.clone())
            .metric_type(metric_type.clone())
            .max_results(MAX_RESULTS)
            .set_next_token(next_token.clone())
            .send()
            .await
            .context("Failed to send get_snapshots request")?;

        let items_received = response.snapshots_data().len();
        println!(
            "Request {}: Received {} items.",
            request_count, items_received
        );

        all_data.extend(response.snapshots_data().iter().cloned());

        next_token = response.next_token().map(|s| s.to_string());
        if next_token.is_none() {
            break;
        }
    }

    println!("Total requests made: {}", request_count);
    println!("Total items fetched: {}", all_data.len());
    Ok(all_data)
}

fn sort_by_count(data: &Vec<Vec<String>>) -> Vec<(String, i32)> {
    let mut queries_with_count: Vec<(String, i32)> = data
        .iter()
        .map(|item| {
            let query = item[0].clone();
            let count = item[1].parse::<i32>().unwrap_or(0); // 検索回数はitem[1]
            (query, count)
        })
        .collect();

    // 検索回数で降順にソート
    queries_with_count.sort_by(|a, b| b.1.cmp(&a.1));

    queries_with_count
}

fn sort_by_zero_result_rate(data: &Vec<Vec<String>>) -> Vec<(String, f64)> {
    let mut queries_with_zero_rate: Vec<(String, f64)> = data
        .iter()
        .map(|item| {
            let query = item[0].clone();
            let zero_rate = item[2].parse::<f64>().unwrap_or(0.0); // ゼロ結果率はitem[2]
            (query, zero_rate)
        })
        .collect();

    // ゼロ結果率で降順にソート
    queries_with_zero_rate.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());

    queries_with_zero_rate
}

人気のあるクエリ (QUERIES_BY_COUNT):
クエリ: The Shawshank Redemption, 検索回数: 1032
クエリ: I'm going to make him an offer he can't refuse., 検索回数: 202
クエリ: Pride and Prejudice, 検索回数: 124
クエリ: Inception, 検索回数: 120
クエリ: One Hundred Years of Solitude, 検索回数: 118
クエリ: Jurassic Park, 検索回数: 56
クエリ: The Godfather, 検索回数: 35
クエリ: I'll be back., 検索回数: 21
・
・
・
Total: xxxx

ゼロ結果率の高いクエリ (QUERIES_BY_ZERO_RESULT_RATE):
クエリ: hoge, ゼロ結果率: 1
クエリ: fugafuga, ゼロ結果率: 1
クエリ: test, ゼロ結果率: 1
クエリ: jjj, ゼロ結果率: 0.5
・
・
・
Total: xxxx