Add tracing to have "connection" among error messages

use std::sync::Arc;
use tracing::{debug, error, info, span};

async fn outer_task(id: u32, param: bool) {
    let outer_span = span!(level: "info", "Workflow", id = id);
    enter!(outer_span); // Enter the outer span

    if param {
        // Spawn and await the inner tasks
        let inner_tasks = (0..4).into_iter().map(|inner_id| async move {
            let inner_span = span!(level: "info", "Task", parent: outer_span.clone(), id = inner_id);
            enter!(inner_span); // Enter the inner span with a link to the outer span

            // Simulate work and logging
            info!(target: &inner_span, "info ecc ecc ecc {} {}", id, inner_id);

            // Exit the inner span
            exit!(inner_span);
        });

        for task in inner_tasks {
            task.await;
        }
    }

    // Exit the outer span
    exit!(outer_span);
}

#[tokio::main]
async fn main() {
    // Set up tracing with a simple console writer
    tracing_subscriber::registry()
        .with(tracing_subscriber::fmt::layer().with_writer(std::io::stdout))
        .init();

    let tasks = (0..10).into_iter().map(|id| {
        let param = id % 2 == 0; // Simulate parameter logic
        outer_task(id as u32, param)
    });

    for task in tasks {
        task.await;
    }
}

Unfortunately pretty unlikely to happen.

If this were to happen, it would allow scraping of the correct results.

link

Error in processing outer object!
[0][5][2]
Error { path: Path { segments: [Seq { index: 0 }, Seq { index: 5 }, Seq { index: 2 }] }, original: Error("invalid type: sequence, expected i32", line: 1, column: 39) }

Error in processing outer object!
[0][5][1]
Error { path: Path { segments: [Seq { index: 0 }, Seq { index: 5 }, Seq { index: 1 }] }, original: Error("invalid type: null, expected i32", line: 1, column: 39) }

[5][7]
Error { path: Path { segments: [Seq { index: 5 }, Seq { index: 7 }] }, original: Error("invalid type: sequence, expected a string", line: 1, column: 18775) }

Add support for max 4 airports as origin and max 4 as destination.

Including suggested times to visit

Remove the uses of unwrap

Possibly send a sort of global stop to all the async functions trugh Apiclient if a 429 error is returned

Add documentation for main methods.

Add if the flight is at its absolute low from price graph

Ensure that all the lines of the output are parsed when parsing inner and outer objects.

Merge? the results in the same object before returning it?

Keep investigating why i receive stale prices. Maybe I just have to take the last envelope? Or maybe the price is the one of the first, and if it is in the second, then the second is valid, ecc?

Error in processing inner object!
[2][0][2][0][2][1][24]
Error { path: Path { segments: [Seq { index: 2 }, Seq { index: 0 }, Seq { index: 2 }, Seq { index: 0 }, Seq { index: 2 }, Seq { index: 1 }, Seq { index: 24 }] }, original: Error("invalid type: sequence, expected a string", line: 1, column: 6315) }

Implement get date grid API

Error in processing inner object!
[1][0][1][24]
Error { path: Path { segments: [Seq { index: 1 }, Seq { index: 0 }, Seq { index: 1 }, Seq { index: 24 }] }, original: Error("invalid type: null, expected a boolean", line: 1, column: 14076) }

Coerce the Flight Response in an easier to use Object.

{
    "status_code:->
    "response: {
        best_flights:[ItineraryContainer],
        other_flights:[],
        trip_cost:Trip_cost,
        price_graph:[]
    }
}
where
ItineraryContainer:{
    flight_by: itinerary.flight_by,
    flight_details:Vec[FlightsDetails]
    departure_airport_code: itinerary.departure_airport_code
    departure_times:FlightDeparture
    departure_date_time: itinerary.departure_date + itinerary.departure_hour
    arrival_airport_code:itinerary....
    arrival_date_time: itinerary.arrival_date + itinerary.arrival_hour
    total_time_minutes:itinerary....
    cost:TripCost
    elissioms:itinerary....
    co2_lowest_route_g:itinerary....co2_lowest_route_g
}

and
FlightsDetails: {
    departure_airport_code:
    destination_airport_code:
    departure_date_time: departure_date + departure_hour
    arrival_date_time: arrival_date + arrival_hour
    legroom:
    Aircraft
    seat_type
    operated_by
    flight_number_code,

}

Error Section:

Multi city trips

Error in processing outer object!
[0][5][2]
Error { path: Path { segments: [Seq { index: 0 }, Seq { index: 5 }, Seq { index: 2 }] }, original: Error("invalid type: sequence, expected i32", line: 1, column: 39) }

Better exposition for final search generation

Error in processing inner object!
[3][0][0][0][2][0][24]
Error { path: Path { segments: [Seq { index: 3 }, Seq { index: 0 }, Seq { index: 0 }, Seq { index: 0 }, Seq { index: 2 }, Seq { index: 0 }, Seq { index: 24 }] }, original: Error("invalid length 1, expected struct Unknown24 with 2 elements", line: 1, column: 7800) }

Error in processing inner object!
.
Error { path: Path { segments: [] }, original: Error("invalid length 15, expected struct RawResponse with 29 elements", line: 1, column: 3379) }

At the moment, the prices returned default of the local currency of the country where you connect from.

There is the need to check if it possible to make a request for the desired currency.

Error in processing inner object!
[4][0][30][0][2][0][10]
Error { path: Path { segments: [Seq { index: 4 }, Seq { index: 0 }, Seq { index: 30 }, Seq { index: 0 }, Seq { index: 2 }, Seq { index: 0 }, Seq { index: 10 }] }, original: Error("invalid length 0, expected struct Hour with 2 elements", line: 1, column: 51180) }
Error in processing inner object!
Error in processing inner object!
[6][0][4]
Error { path: Path { segments: [Seq { index: 6 }, Seq { index: 0 }, Seq { index: 4 }] }, original: Error("invalid length 1, expected struct CheaperTravelDifferentPlaces with 2 elements", line: 1, column: 2688) }

Return Single structs from the various API calls.

The underlying can be a vec, its fine, but the return should be a single object.

This enables having all the methods on a single object instead that scattered around.