impl<T> FromRequest for Form<T>
where
    T: DeserializeOwned + 'static,
{
    type Error = actix_web::Error;
    async fn from_request(req: &HttpRequest, payload: &mut Payload) -> Result<Self, Self::Error> {
        // Omitted stuff around extractor configuration (e.g. payload size limits)
        match UrlEncoded::new(req, payload).await {
            Ok(item) => Ok(Form(item)),
            // The error handler can be customised.
            // The default one will return a 400, which is what we want. Err(e) => Err(error_handler(e))
        }
    }
}

serde_urlencoded::from_bytes::<T>(&body).map_err(|_| UrlencodedError::Parse)

#[derive(serde::Deserialize)] pub struct FormData {
    email: String,
    name: String,
}

// Let's start simple: we always return a 200 OK
async fn subscribe(_form: web::Form<FormData>) -> HttpResponse {
    HttpResponse::Ok().finish()
}

// src/configuration.rs
pub fn get_configuration() -> Result<Settings, config::ConfigError> {
    let settings = config::Config::builder()
        .add_source(config::File::new("configuration", config::FileFormat::Yaml))
        .build()?;

    settings.try_deserialize::<Settings>()
}

// src/routes/subscriptions.rs
pub async fn subscribe(
    _form: web::Form<FormData>,
    _connection: web::Data<PgConnection>,

// src/main.rs
let connection_pool = PgPool::connect(&configuration.database.connection_string())
    .await
    .expect("Failed to connect to Postgres.");
..
// src/startup.rs
pub fn run(listener: TcpListener, db_pool: PgPool) -> Result<Server, std::io::Error> {
    let db_pool = web::Data::new(db_pool);
    let server = HttpServer::new(move || {
        App::new()
            .route("/health_check", web::get().to(health_check))
            .route("/subscriptions", web::post().to(subscribe))
            .app_data(db_pool.clone())
..
// src/routes/subscriptions.rs
pub async fn subscribe(form: web::Form<FormData>, pool: web::Data<PgPool>) -> HttpResponse {
    sqlx::query!(..)
    .execute(pool.get_ref())
    .await;

async fn spawn_app() -> TestApp {
    let listener = TcpListener::bind("127.0.0.1:0").expect("Failed to bind random port");
    let port = listener.local_addr().unwrap().port();
    let address = format!("http://127.0.0.1:{}", port);

    let configuration = get_configuration().expect("Failed to read configuration.");
    let connection_pool = PgPool::connect(&configuration.database.connection_string())
        .await
        .expect("Failed to connect to Postgres.");

    let server = run(listener, connection_pool.clone()).expect("Failed to bind address");
    let _ = tokio::spawn(server);

    TestApp {
        address,
        db_pool: connection_pool,
    }
}

// tests/health_check.rs
configuration.database.database_name = uuid::Uuid::new_v4().to_string();
let connection_pool = configure_database(&configuration.database).await;
..
async fn configure_database(config: &zero2prod::configuration::DatabaseSettings) -> PgPool {
    let mut connection = PgConnection::connect(&config.connection_string_without_db())
        .await
        .expect("Failed to connect to Postgres.");

    connection
        .execute(format!(r#"CREATE DATABASE "{}";"#, config.database_name).as_str())
        .await
        .expect("Failed to create database.");

    let connection_pool = PgPool::connect(&config.connection_string())
        .await
        .expect("Failed to connect to Postgres.");

    sqlx::migrate!("./migrations")
        .run(&connection_pool)
        .await
        .expect("Failed to migrate the database.");

    connection_pool
}

fn fallible_operation() -> Result<String, String> { ... }

pub fn main() {
  match fallible_operation() {
    Ok(success) => {
      log::info!("Operation succeeded: {}", success);
    }
    Err(err) => {
      log::error!("Operation failed: {}", err);
    }
  }
}

// src/routes/startup.rs
let server = HttpServer::new(move || {
    App::new()
        .wrap(Logger::default())
..

pub trait Log: Sync + Sned {
  fn enabled(&self, metadata: &Metadata) -> bool;
  fn log(&self, record: &Record);
  fn flush(&self);
}

// src/main.rs
async fn main() -> std::io::Result<()> {
// `init` does call `set_logger`, so this is all we need to do.
// We are falling back to printing all logs at info-level or above
// if the RUST_LOG environment variable has not been set.
env_logger::Builder::from_env(Env::default().default_filter_or("info")).init();

let request_span = tracing::info_span!(
    "Adding a new subscriber",
    %request_id,
    subscriber_email = %form.email,
    subscriber_name = %form.name
);
let _request_span_guard = request_span.enter();

//! src/routes/subscriptions.rs
use tracing::Instrument;
// ..

let query_span = tracing::info_span!("Saving new subscriber details in the database");
match sqlx::query!(/* */)
.execute(pool.get_ref())
.instrument(query_span)
.await

//! src/main.rs
let env_filter = EnvFilter::try_from_default_env().unwrap_or(EnvFilter::new("info"));
let formatting_layer = BunyanFormattingLayer::new("zero2prod".into(), std::io::stdout);
let subscriber = Registry::default()
    .with(env_filter)
    .with(JsonStorageLayer)
    .with(formatting_layer);
set_global_default(subscriber).expect("Failed to set subscriber.");

//! src/main.rs
LogTracer::init().expect("Failed to set logger.");