leyline-http 0.1.1

HTTP client that mimics browsers on the wire
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

use std::time::Duration;

use bytes::Bytes;

use super::{CURRENT, Ctx, ms};

#[derive(Debug)]
#[non_exhaustive]
pub enum BodyOutcome<'a> {
    Complete,
    Failed(&'a std::io::Error),
    Dropped,
}

#[derive(Debug)]
#[non_exhaustive]
pub struct BodyEnd<'a> {
    pub id: u64,
    pub bytes: u64,
    pub elapsed: Duration,
    pub outcome: BodyOutcome<'a>,
}

pub(crate) struct BodyWatch {
    ctx: Ctx,
    bytes: u64,
    ended: bool,
}

impl BodyWatch {
    pub(crate) fn begin() -> Option<Self> {
        CURRENT
            .try_with(|ctx| Self {
                ctx: ctx.clone(),
                bytes: 0,
                ended: false,
            })
            .ok()
    }

    pub(crate) fn observe(&mut self, item: Option<&std::io::Result<Bytes>>) {
        match item {
            Some(Ok(chunk)) => self.bytes += chunk.len() as u64,
            Some(Err(err)) => self.end(BodyOutcome::Failed(err)),
            None => self.end(BodyOutcome::Complete),
        }
    }

    fn end(&mut self, outcome: BodyOutcome<'_>) {
        if self.ended {
            return;
        }
        self.ended = true;
        let (id, start) = self.ctx.root;
        self.ctx.hook.body(&BodyEnd {
            id,
            bytes: self.bytes,
            elapsed: start.elapsed(),
            outcome,
        });
    }
}

impl Drop for BodyWatch {
    fn drop(&mut self) {
        if !std::thread::panicking() {
            self.end(BodyOutcome::Dropped);
        }
    }
}

pub(super) fn render(ev: &BodyEnd<'_>) {
    let elapsed_ms = ms(ev.elapsed);
    match ev.outcome {
        BodyOutcome::Complete => {
            tracing::info!(target: "leyline::trace", id = ev.id, bytes = ev.bytes, elapsed_ms, outcome = "complete", "body")
        }
        BodyOutcome::Failed(err) => {
            tracing::info!(target: "leyline::trace", id = ev.id, bytes = ev.bytes, elapsed_ms, outcome = "error", kind = ?err.kind(), error = %err, "body")
        }
        BodyOutcome::Dropped => {
            tracing::info!(target: "leyline::trace", id = ev.id, bytes = ev.bytes, elapsed_ms, outcome = "dropped", "body")
        }
    }
}