cardamon 0.0.1

Cardamon is a tool to help development teams measure the power consumption and carbon emissions of their software.
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245

use crate::{
    dao::{self, iteration::RunId}, dataset::DatasetBuilder, server::{
        errors::ServerError,
        types::{
            Iteration, Pagination, Scenario, Scenario5Average, ScenarioParams, ScenarioResponse, ScenarioRun, ScenariosParams, ScenariosResponse, Usage
        }
    }
};
use axum::{
    extract::{Path, Query, State},
    Json,
};
use chrono::Utc;
use sea_orm::DatabaseConnection;
use std::collections::HashMap;
use tracing::{instrument, debug, info};

#[instrument(name = "Get list of scenarios")]
pub async fn get_scenarios(
    State(db): State<DatabaseConnection>,
    Query(params): Query<ScenariosParams>,
) -> Result<Json<ScenariosResponse>, ServerError> {
    let begin = params.from_date.unwrap_or(0);
    let end = params
        .to_date
        .unwrap_or_else(|| Utc::now().timestamp_millis());
    let page = params.page.unwrap_or(1);
    let page = page - 1; // DB needs -1 indexing
    let limit = params.limit.unwrap_or(5);

    info!("Fetching scenarios between {} and {}", begin, end);

    let dataset = match &params.search_query {
        Some(query) => {
            DatasetBuilder::new(&db)
                .scenarios_by_name(query)
                .all()
                .last_n_runs(5)
                .await?
        }
        None => {
            DatasetBuilder::new(&db)
                .scenarios_in_range(begin, end)
                .all()
                .last_n_runs(5)
                .await?
        }
    };

    let total_scenarios = dataset.total_unique_scenarios() as u32;
    let total_pages = dataset.total_pages(limit); // Returns correct number ( 1 based indexing )
    let paginated_scenarios = dataset.paginated_unique_scenarios(page, limit);

    debug!("Processing {} scenarios", paginated_scenarios.len());

    let mut scenario_responses = Vec::new();
    for scenario_name in paginated_scenarios {
        let last_runs = dataset.last_n_runs_for_scenario(&scenario_name, 5);

        let mut scenario_map: HashMap<i32, Vec<Iteration>> = HashMap::new();
        for run in &last_runs {
            scenario_map
                .entry(run.iteration().run_id)
                .or_default()
                .push(Iteration {
                    run_id: run.iteration().run_id,
                    scenario_name: run.iteration().scenario_name.clone(),
                    iteration: run.iteration().count,
                    start_time: run.iteration().start_time,
                    stop_time: run.iteration().stop_time,
                    usage: None,
                    // Use /scenario/ID for this
                    /*
                    usage: Some(
                        run.metrics()
                            .iter()
                            .map(|m| Usage {
                                cpu_usage: m.cpu_usage,
                                timestamp: m.time_stamp,
                            })
                            .collect(),
                    ),
                    */
                });
        }

        let avg_co2_emission: f64 = 2.0; // Placeholder value
        let avg_power_consumption: f64 = 2.0; // Placeholder value
        let (total_cpu_usage, total_metrics) = last_runs
            .iter()
            .flat_map(|run| run.metrics())
            .fold((0.0, 0), |(sum, count), m| (sum + m.cpu_usage, count + 1));

        let avg_cpu_utilization: f64 = if total_metrics > 0 {
            total_cpu_usage / total_metrics as f64
        } else {
            0.0
        };
        let last_start_time: u64 = last_runs
            .iter()
            .map(|run| run.iteration().start_time)
            .max()
            .unwrap_or(0) as u64;

        let co2_emission_trend: Vec<f64> = (1..=10).map(|x| x as f64).collect(); // Placeholder

        let runs: Vec<ScenarioRun> = scenario_map
            .into_iter()
            .map(|(run_id, iterations)| ScenarioRun { run_id, iterations })
            .collect();

        scenario_responses.push(Scenario5Average {
            name: scenario_name,
            avg_co2_emission,
            last_5_avg_cpu: avg_cpu_utilization,
            avg_power_consumption,
            co2_emission_trend,
            last_start_time,
            runs,
        });
    }

    // Sort by scenario last time
    scenario_responses.sort_by(|a, b| b.last_start_time.cmp(&a.last_start_time));

    let pagination = Pagination {
        current_page: page + 1, // Page is DB value which uses 0 based indexing, user needs 1 based
        // indexing
        per_page: limit,
        total_scenarios,
        total_pages,
    };

    let response = ScenariosResponse {
        scenarios: scenario_responses,
        pagination,
    };

    debug!(
        "Returning response with {} scenarios",
        response.scenarios.len()
    );
    Ok(Json(response))
}

#[instrument(name = "Get specific scenario")]
pub async fn get_scenario(
    State(db): State<DatabaseConnection>,
    Path(scenario_id): Path<String>,
    Query(params): Query<ScenarioParams>,
) -> Result<Json<ScenarioResponse>, ServerError> {
    let page = params.page.unwrap_or(1);
    let limit = params.limit.unwrap_or(5);

    // Fetch all unique run_ids for the scenario
    let all_run_ids = dao::iteration::fetch_unique_run_ids(&scenario_id, &db).await?;

    // Calculate pagination
    let total_runs = all_run_ids.len();
    let total_pages = (total_runs as f64 / limit as f64).ceil() as u32;
    let start_index = (page - 1) as usize * limit as usize;
    let end_index = (start_index + limit as usize).min(total_runs);

    // Paginate run_ids
    let paginated_run_ids = &all_run_ids[start_index..end_index];

    let mut scenario_runs = Vec::new();
    let mut total_cpu_utilization = 0.0;
    let mut total_iterations = 0;
    let mut last_start_time = 0u64;

    for RunId { run_id } in paginated_run_ids {
        let iterations = dao::iteration::fetch_by_scenario_and_run(&scenario_id, *run_id, &db)
            .await?;

        let mut run_iterations = Vec::new();
        for iteration in iterations {
            let metrics = dao::metrics::fetch_within(*run_id, iteration.start_time, iteration.stop_time, &db)
                .await?;

            let usages: Vec<Usage> = metrics
                .iter()
                .map(|m| Usage {
                    cpu_usage: m.cpu_usage,
                    timestamp: m.time_stamp,
                })
                .collect();

            total_cpu_utilization += usages.iter().map(|u| u.cpu_usage).sum::<f64>();
            total_iterations += usages.len();
            last_start_time = last_start_time.max(iteration.start_time as u64);

            run_iterations.push(Iteration {
                run_id: iteration.run_id,
                scenario_name: iteration.scenario_name.clone(),
                iteration: iteration.count,
                start_time: iteration.start_time,
                stop_time: iteration.stop_time,
                usage: Some(usages),
            });
        }

        scenario_runs.push(ScenarioRun {
            run_id: *run_id,
            iterations: run_iterations,
        });
    }

    let avg_cpu_utilization = if total_iterations > 0 {
        total_cpu_utilization / total_iterations as f64
    } else {
        0.0
    };

    let scenario_response = ScenarioResponse {
        scenario: Scenario {
            name: scenario_id,
            avg_co2_emission: 0.0, // Placeholder value
            avg_cpu_utilization,
            avg_power_consumption: 0.0,     // Placeholder value
            co2_emission_trend: Vec::new(), // Fill this if you have the data
            last_start_time,
            runs: scenario_runs,
        },
        pagination: Pagination {
            current_page: page,
            total_pages,
            per_page: limit,
            total_scenarios: total_runs as u32,
        },
    };

    debug!(
        "Returning scenario response with {} runs",
        scenario_response.scenario.runs.len()
    );
    Ok(Json(scenario_response))
}

// #[instrument(name = "Get database url")]
// pub async fn get_database_url() -> Result<Json<String>, ServerError> {
//     //TODO change this to NOT include the password
//     let db_url = std::env::var("DATABASE_URL").unwrap();
//     Ok(Json(db_url))
// }